CtrlK
Toolhouse is a cloud infrastructure platform that helps developers equip large language models with tools, actions, and knowledge. Founded in 2024 and headquartered in Oakland, California, the company offers a universal SDK, a managed Tool Store of pre-built integrations, and an Agent Studio that lets users build and deploy AI agents directly from natural language descriptions. Toolhouse positions itself as a backend-as-a-service layer for AI agents, handling function definitions, execution environments, and result formatting so developers can add working tool execution in a few lines of code.
The platform supports Model Context Protocol (MCP) as its primary integration standard, making it useful for teams that want managed MCP infrastructure without running their own servers. Toolhouse is used by developers at companies including Cloudflare, NVIDIA, Groq, and Snowflake.
Toolhouse was co-founded by Daniele Bernardi and Orlando Kalossakas. Bernardi serves as CEO. He started his career as a software engineer in Italy, then moved into developer relations, working at Facebook and later at Twitter where he served as Head of Developer Relations. His experience building developer communities at two of the largest social platforms directly shaped Toolhouse's developer-first approach.
Kalossakas brings a background in developer marketplaces and platform growth. Before Toolhouse, he co-founded Dashcam, an AI agent for QA engineering and bug reporting, and held roles at Kong, Stripe, and Mashape (which was acquired by RapidAPI). He was also at Blockspring (acquired by Coinbase) and Mailgun (acquired by Rackspace).
Bernardi has spoken publicly about founding Toolhouse as a response to what he saw as a broken AI infrastructure ecosystem: platforms priced and designed for large enterprises, leaving independent developers and small teams without affordable options. He has described Toolhouse's philosophy as the "Toyota of AI," prioritizing reliability and accessibility over premium positioning.
Toolhouse Technologies, Inc. was incorporated on June 24, 2024. The company grew quickly in its first year. By early 2025, Toolhouse reported having tens of thousands of agents running monthly through its platform. It attracted attention in the developer community partly through events showcasing integrations with Groq's inference hardware and Snowflake's data platform.
Early traction came from developers building prototypes and MVPs who wanted pre-built tool integrations without writing boilerplate code. The platform's emphasis on minimal setup, often cited as a three-line integration pattern, helped it gain adoption among hackathon participants and independent developers.
Toolhouse raised an initial pre-seed round from Ganas Ventures, 500 Global, and Vento. Ganas Ventures, which focuses on pre-seed and seed-stage startups, announced its investment publicly. 500 Global, the global venture firm formerly known as 500 Startups, also participated. Vento is listed as an institutional investor in company profiles. The specific dollar amount of the pre-seed round was not publicly disclosed.
The company adopted a lean approach to fundraising, building toward profitability without the heavy capital requirements common in AI infrastructure startups. Bernardi has described this strategy explicitly, distinguishing Toolhouse from what he characterized as "VC-bloated" AI platforms.
Toolhouse provides three main components: a universal SDK, a Tool Store, and an Agent Studio. These operate together as a platform, though developers can use them independently depending on what they are building.
The Toolhouse SDK is available for Python and TypeScript. It integrates with any OpenAI-compatible API, which means developers can use it with GPT-4o, Claude, Groq-hosted Llama models, and other providers that follow the same function-calling interface. The SDK follows a consistent pattern: initialize the Toolhouse client, call get_tools() to retrieve the available function definitions, pass those to the LLM on each request, and then call run_tools() to execute any tool calls the model requested.
This three-function pattern handles the parts of tool use that are often tedious to implement: maintaining a registry of tool schemas, routing LLM tool call requests to the correct execution environment, and handling retries and errors. The SDK also supports local tools defined by the developer alongside hosted tools from the Tool Store.
The SDK supports both synchronous and asynchronous modes in Python. TypeScript support includes a registerLocalTool() method for custom tool definitions. Both SDKs support streaming.
The Tool Store is a curated marketplace of pre-built tools optimized to work with LLMs. Each tool in the store is designed specifically for AI agent use, with descriptions and parameter schemas tuned for function calling. Developers can install tools from the store with a single click from the dashboard, and those tools become available through get_tools() immediately.
Documented tools in the Tool Store include:
Higher-tier plans add integrations with Google Calendar, Gmail, Slack, HubSpot, Mailchimp, Google Drive, and other business tools.
Agent Studio is a no-code interface for building what Toolhouse calls "AI workers," which are agents designed for repeatable, structured tasks. A developer or business user describes what the agent should do in plain language, and Toolhouse generates the underlying agent configuration, including which tools to use, how often to run, and what triggers to respond to.
Agents can be activated on four interaction modes: scheduled execution at a defined cadence (as frequent as every 10 minutes), event-driven execution via webhooks, chat-based interaction where a user message initiates the task, and email-based interaction where each agent receives a unique @toolhouse.app email address.
Agents built in Agent Studio can also be deployed as REST APIs at https://agents.toolhouse.ai/$AGENT_ID, accepting Bearer token authentication. This means agents created visually can be called programmatically from other systems. POST requests start new sessions and return a run ID; PUT requests continue existing sessions using that ID.
Agents support knowledge files in formats including Markdown, plain text, CSV, HTML, JavaScript, TypeScript, and C/C++. These files provide persistent context that the agent references across runs.
Toolhouse supports Model Context Protocol through a dedicated bridge package (toolhouse-mcp). This lets MCP-compatible clients connect to Toolhouse's tool catalog without running custom MCP servers. For developers already working within the MCP ecosystem, Toolhouse becomes a managed hosting layer for the tools their agents call.
This approach is distinct from platforms like Composio that manage OAuth connections to SaaS services. Toolhouse focuses on the execution environment and tool registry, while authentication to external services is handled separately or through supported OAuth integrations in higher tiers.
Toolhouse runs tools on globally distributed cloud infrastructure with low-latency execution. Each agent runs in an isolated sandbox, which prevents cross-agent data access and limits the blast radius of errors or unexpected tool behavior. Execution is logged, and the dashboard exposes tool call inputs and outputs for debugging. The platform also provides automated evaluations for testing agent behavior before deployment.
Toolhouse's integrations fall into two categories. Built-in integrations are maintained directly by Toolhouse and require no external authentication setup. Connection-required integrations link to third-party services through OAuth flows managed from the Toolhouse dashboard.
Documented built-in capabilities include semantic web search, sandboxed code execution, vector memory storage (via Pinecone and MongoDB Atlas), and email sending (via SendGrid).
Documented OAuth-based integrations include Google Calendar, Gmail, Slack, HubSpot, Mailchimp, and Google Drive. Workflow automation connectors exist for Zapier and n8n.
The platform also supports custom tools. Developers can register local tools using the SDK's registerLocalTool() method (TypeScript) or by passing locally defined functions alongside the hosted tools. This lets teams combine Toolhouse's managed tools with their own proprietary integrations in a single tool call flow.
As of early 2026, the total documented integration count is approximately 40. This is substantially smaller than Composio's catalog of over 250 pre-built connectors.
Several platforms address the same general problem of giving AI agents access to external tools and services. Toolhouse, Composio, and Arcade.dev are three of the most frequently compared.
Composio is a developer-first integration platform with over 250 pre-built connectors to SaaS applications, a CLI tool, and frameworks for per-user OAuth authentication. It supports LangChain, LlamaIndex, the OpenAI Agents SDK, and other orchestration frameworks as first-class integration targets.
Toolhouse focuses on simplicity and minimal setup. Its three-line SDK pattern is designed to get tool execution working faster than Composio's more involved configuration process. Independent developers and small teams building prototypes or MVPs tend to find Toolhouse easier to start with.
The main trade-off is breadth. Composio's catalog is much larger and its OAuth handling is more mature for multi-tenant production deployments where each end user connects their own third-party accounts. Toolhouse's tool catalog is better suited to single-tenant or developer-controlled integrations. Composio also offers closed-source pre-built tools, which critics note limits the ability to inspect or modify integration behavior; Toolhouse has faced similar feedback.
| Feature | Toolhouse | Composio |
|---|---|---|
| Pre-built integrations | ~40 | 250+ |
| MCP support | Yes | Yes |
| Per-user OAuth | Limited | Full |
| Setup time | Minutes (3-line SDK) | Hours |
| Pricing model | Credits/month + free tier | Subscription + usage |
| Best fit | Prototypes, MVPs, small teams | Production agents, enterprise |
| Open source tools | Partial | No |
Arcade.dev, founded in February 2024 by Alex Salazar (former Okta VP) and Sam Partee (former Redis engineer, contributor to LangChain and LlamaIndex), raised $12 million in seed funding in March 2025. The round was led by Laude Ventures, the fund launched by Andy Konwinski (co-founder of Perplexity and Databricks).
Arcade.dev's core design principle is OAuth delegation: agents act as individual users through proper OAuth flows rather than using shared bot tokens or service accounts. This model, borrowed from enterprise identity management, is important for multi-user products where each end user needs to authorize the agent to access their personal services like Gmail or Google Calendar.
Toolhouse does not implement the same per-user OAuth delegation model. It is primarily designed for scenarios where the developer controls the authenticated accounts. This makes Arcade.dev a better fit for consumer-facing or enterprise SaaS products where agents need to act on behalf of many distinct users, while Toolhouse fits internal automation or developer tooling where authentication is centralized.
| Feature | Toolhouse | Arcade.dev |
|---|---|---|
| Founded | 2024 | 2024 |
| Funding | Pre-seed (undisclosed) | $12M seed (March 2025) |
| Pre-built integrations | ~40 | ~112 |
| Auth model | Centralized OAuth | Per-user OAuth delegation |
| MCP support | Yes | Yes |
| Open source runtime | Partial (MCP bridge) | No (closed Docker container) |
| Best fit | Developer tools, internal automation | Multi-user product agents |
AgentPatch, another alternative, uses a pay-per-call model (approximately $0.0001 per credit) with a CLI-first interface and around 50 tools. It requires only minutes to set up and appeals to developers building CLI-based agents.
Nango provides authentication infrastructure only, with no pre-built tools. It supports over 700 APIs with full code-level customization of integration logic and strong observability through OpenTelemetry. Teams that want to own their integration definitions entirely, rather than relying on a managed catalog, use Nango as the auth layer alongside their own tool implementations.
Toolhouse offers a free tier and two paid tiers as of 2025.
| Plan | Price | Credits | Key features |
|---|---|---|---|
| Free | $0 | 500 tool executions/month | Core SDK access, Tool Store, unlimited platform access |
| Pro | $10/month | 100 credits, up to 100 runs | Web search, file uploads, Zapier and n8n integrations |
| Business | $500/month | 15,000 credits/month | Agent Studio, advanced models, white-glove onboarding, phone and Slack support, human-in-the-loop features |
| Enterprise | Custom | Custom | Dedicated support, on-premises deployment, private data hosting, compliance features |
The credit model means tool executions count against a monthly quota. Heavier usage, such as agents that run web searches or code execution on each request, can exhaust a tier's credits faster than agents that primarily use memory or lightweight integrations.
The Pro tier at $10 per month is substantially cheaper than most enterprise AI infrastructure services and is designed to be accessible for individual developers and independent projects. Bernardi has pointed to global pricing accessibility as a deliberate choice, noting that AI infrastructure costs calibrated to San Francisco salaries are prohibitive for developers in markets like India, Germany, and Brazil.
Toolhouse's documentation and community resources describe five recurring patterns for how teams use the platform.
Briefing agents aggregate information from multiple sources on a schedule, such as pulling from RSS feeds, internal databases, or APIs each morning and producing a summarized report delivered by email or Slack. These use the scheduling trigger and web search or database tools.
Triage and routing agents monitor an inbound channel (email, webhook, or service event) and direct items to the right destination, such as classifying customer support tickets and assigning them to queues, or reading incoming email threads and creating calendar events or CRM entries.
Analysis and recommendation agents interpret data to produce recommendations. An example cited in Toolhouse's documentation is an insurance-sector agent that retrieves policy data, compares quotes, and produces a feasibility summary without human involvement.
Content creation agents generate and tailor text for specific audiences, such as listing descriptions, marketing copy, or outbound message drafts.
Developer tooling is the most common use case among the platform's early adopters. Teams use Toolhouse to add capabilities to coding assistants, build customer support agents, and create job search agents. The examples repository on GitHub includes implementations for a customer support agent, a job search agent, and a code assistant, each built using a few hundred lines of Python or TypeScript.
Toolhouse has received generally positive feedback from developers who prioritize speed of setup over integration breadth. It is frequently cited in comparisons as having "the lowest setup friction" among tool execution platforms, with reviewers noting that a working agent with full tool execution can be deployed in under five minutes.
Criticism has focused on the relatively small integration catalog compared to Composio and the lack of per-user OAuth delegation compared to Arcade.dev. For teams building production agents that touch many third-party services on behalf of many users, Toolhouse's current scope requires supplementing it with other infrastructure. The "managed everything" architecture, while convenient for simple use cases, limits customization for complex orchestration scenarios.
The platform's traffic analysis shows its primary user base is concentrated in the United States (approximately 56%), followed by India (around 21%) and Germany (approximately 12%). This geographic distribution aligns with Bernardi's stated goal of building for developers outside major US tech hubs.
Toolhouse was highlighted in a 2025 EVENT report by ENGINE's StartupsEverywhere program as a San Francisco startup working on AI democratization.
The main limitations reported by developers include:
The tool catalog is smaller than Composio's. Teams that need broad SaaS integrations or specialized connectors often find gaps in the Toolhouse store that require building custom tools or using a different platform.
The platform depends on Toolhouse's cloud runtime. Developers cannot fully self-host or run the execution environment on their own infrastructure without the Enterprise plan's on-premises option. If Toolhouse has an outage, agents built on it are unavailable.
Per-user OAuth is limited compared to Arcade.dev. Building multi-user products where each end user connects their own accounts to an agent requires additional authentication infrastructure that Toolhouse does not provide natively on lower-tier plans.
The platform is newer than LangChain and other frameworks with larger communities. Documentation gaps and limited community-contributed examples can slow down less experienced developers.