Programmatic MCP Prototype

Exposes a search_tools meta-tool that uses a smaller Claude Haiku model as a subagent to discover relevant tools from a full registry by natural language query, avoiding context bloat by deferring tool schema loading until needed. The system maintains a complete tool registry but only surfaces 4 meta-tools to the main agent, delegating discovery to a secondary LLM that selects appropriate tools based on user intent.

Generates TypeScript bindings for discovered MCP tools and allows the agent to write complete programs that import, compose, and execute multiple tools with control flow (loops, conditionals, error handling). The system translates MCP tool schemas into executable TypeScript functions, enabling the agent to write multi-step workflows as code rather than making sequential tool calls.

Provides a get_tool_definition meta-tool that retrieves the full JSON schema for any available tool, enabling agents to inspect tool parameters, return types, and documentation before deciding whether to use a tool. The system maintains metadata about all available tools and exposes this through a queryable interface.

Provides a list_tool_names meta-tool that returns all available tool names from the aggregated tool registry, enabling agents to enumerate what tools are available without loading full schemas. This lightweight discovery mechanism allows agents to understand the scope of available capabilities.

Executes agent-generated TypeScript code in isolated Docker containers with a persistent workspace directory that survives across multiple code submissions. Each container has access to MCP tool proxies, can read/write files to the workspace, and maintains state between executions, enabling agents to build up intermediate results and reuse them in subsequent code runs.

Allows agents to define and persist reusable TypeScript functions (skills) that wrap and compose multiple MCP tools, storing these skills in the workspace for use in subsequent code executions. Skills are generated TypeScript functions that encapsulate complex multi-tool workflows, enabling agents to build a library of domain-specific capabilities that can be imported and reused.

Aggregates tools from multiple MCP servers (local and remote) through a unified ToolProxy abstraction that routes tool calls to the appropriate backend server based on tool name. The system maintains a registry of configured MCP servers and dynamically routes tool invocations to the correct backend, enabling agents to work with tools from heterogeneous sources as a unified interface.

Manages OAuth flows and API credentials for tools that require authentication, storing credentials securely and injecting them into the execution environment when tools are invoked. The system handles OAuth token refresh, credential rotation, and secure credential injection into containerized code execution contexts.

Implements a core agent loop that manages multi-turn conversations between the LLM and tools, handling message routing, tool call parsing, execution, and result injection back into the conversation context. The system maintains conversation history, parses tool calls from LLM responses, executes tools, and feeds results back to the LLM for iterative refinement.

Exposes the agent system through both a command-line interface (for local development) and an HTTP REST API (for remote access), allowing users to interact with the agent via terminal commands or HTTP requests. Both interfaces route to the same underlying agent loop, providing multiple access patterns for different deployment scenarios.

Supports configuring MCP servers through environment variables or config files, with support for both local servers (stdio-based) and remote servers (HTTP/SSE-based). The system dynamically loads server configurations at startup and maintains connections to all configured servers, enabling flexible deployment across different environments.

Automatically generates TypeScript function signatures and type definitions from MCP tool schemas, creating executable bindings that agents can import and call within containerized code. The code generator translates JSON schema definitions into typed TypeScript functions with proper parameter validation and return types.