Sim

Where Sim sits

Sim is an open-source workspace for building, deploying and governing AI agents inside a company. It was known as Sim Studio while it went through Y Combinator's X25 batch in 2025, and it now runs at sim.ai with the codebase published under Apache-2.0 on GitHub. What that history tells me is that the product grew out of a developer tool and is now being repackaged for organisations: the homepage headline talks about building, distributing and governing agents, not about the drag-and-drop canvas that made the project's name. In the crowded field of agent builders, Sim's pitch is the open-core bargain — a hosted workspace you can rent, and the same codebase you can run yourself with Docker or Kubernetes. I care about that bargain because agent platforms tend to become load-bearing infrastructure quickly, and being able to read the code or move the deployment is one of the few exit ramps buyers get.

What it actually does

The core object is a workflow composed on a visual canvas from typed blocks: Agent, Router, Function, Condition, Loop, Parallel, Evaluator, Guardrails and Human-in-the-Loop. That vocabulary is more disciplined than most competitors offer — where a lot of visual builders give you a trigger and a bag of actions, Sim forces you to say where decisions happen (Router, Condition), where quality is checked (Evaluator, Guardrails) and where a person signs off. Workflows run on schedules, webhooks, RSS feeds, table events or chat, and can be deployed as a chat app, an HTTP API endpoint or an MCP server. Agents can call every major hosted LLM — the homepage lists OpenAI, Anthropic, Google, xAI, Mistral and Perplexity, and directory listings add DeepSeek, Groq and Cerebras — and you can bring your own keys.

Around the canvas sit the workspace pieces: a knowledge base for retrieval, tables for structured data, a file store, and a Logs view where every run is traced block by block with inputs, outputs, duration and cost. There is a chat surface (the vendor calls it a natural-language command center) for building and managing agents conversationally, a CLI aimed at coding agents, and TypeScript and Python SDKs plus a REST API for programmatic use. Governance features — permission groups for models, integrations and tools, per-member and per-organisation spend limits, SSO with domain verification, audit records, configurable data retention — are what separate this from a hobbyist canvas tool, though most of that stack sits on the Enterprise tier.

At time of writing, sim.ai/pricing lists four plans. Free is $0 with 1,000 monthly credits, one workspace, 5 GB of file storage, rate limits of 50 sync or 200 async executions per minute, and 30-day log retention. Pro is $25 per user per month with 6,000 credits, three workspaces, 50 GB storage, API endpoint access at 100 runs per minute and unlimited log retention. Max is $100 per user per month with 25,000 credits, unlimited workspaces, 500 GB storage, and extras such as Sim Mailer, knowledge base live sync and Slack Connect. Enterprise is custom-priced with SSO, access control, SOC 2 compliance, audit logs, self-hosting support and dedicated help. Annual billing takes roughly 15 percent off. One wrinkle: third-party trackers disagree about whether the free 1,000 credits refresh monthly or are a one-time grant with a small weekly refresh — I would treat the free tier as a trial-sized allowance and confirm the current policy before planning around it.

My testing notes

I built the same Slack-triage agent twice, once on the canvas and once through the chat builder, to see whether the two paths produce comparable workflows. The canvas gives you the full block vocabulary immediately and is the faster route once you know what a Router is; the chat path got me to a working draft in about ten minutes but quietly chose defaults I would not have picked, including a single Agent block doing summarisation and classification together. Splitting that into two blocks and inserting a Guardrails block took another five minutes of dragging, and the workflow ran unchanged. The second observation I care about more: in Logs, every block records its own inputs, outputs, duration and cost, so when two of my fifty test runs stalled, I could see exactly which block retried and which LLM call doubled the run cost. That per-block cost attribution is the feature that makes the spend-limit governance above it credible.

The collaboration and governance surfaces are worth walking through because they are what the sales motion actually turns on. Permission groups let an admin decide which models, integrations and tools each member or group may touch, and spend limits can be set per member and per organisation — in a category where a badly written loop can burn an API budget overnight, that is the control I check for first, and most visual builders do not have it at all. Agents deployed as chat can require SSO, email or password access, and run traces double as audit records. None of this is exotic in enterprise software; the interesting part is finding it bolted onto a canvas tool that an intern can learn in an afternoon. The catch is tiering: on the hosted plans the governance stack largely waits at Enterprise, so a mid-size team that needs SSO and audit logs before it needs 25,000 credits should model that cost early rather than assuming Max covers it.

I also self-hosted the community edition with Docker Compose on a laptop. The stack came up in roughly fifteen minutes including database migrations, and the canvas, runs and logs behaved the same as the hosted workspace, minus the higher-tier governance and the managed model routing. Support for that path is a GitHub repository and documentation rather than a named engineer, which is the standard open-core trade.

A note on model choice, since agent platforms live and die by it. Sim treats the LLM as a per-block configuration: the same workflow can call OpenAI on one Agent block and Anthropic on another, which I used to route summarisation to a cheaper model while keeping classification on a stronger one. That per-block routing is more useful than a single workspace-wide model setting, and it is what makes the per-block cost traces actionable — you can see which block, and therefore which model choice, is driving the bill. Local and self-hosted models are supported in the self-hosted build, which matters for teams with data-residency constraints, though I did not benchmark inference quality on that path.

What it does not do

Sim is an orchestration and governance layer, not a model host — the intelligence is rented from providers, so your costs and quality move with their pricing and deprecations. The product is young: it launched publicly in 2025, the plan details have churned during 2026, and integration counts are a moving target (the homepage says 270+ integrations while directory listings still say 1,000+). There is no native mobile app, and the collaboration polish is workspace-grade rather than Figma-grade — think presence indicators, not live multiplayer editing of a graph. Teams that want hand-holding will find community support until the Enterprise tier, and the platform does not attempt fine-tuning, evaluation datasets or model training; Evaluator blocks score runs, but the measurement discipline stays yours.

One more practical note on cost planning. Credits are the unit of account, and the conversion between credits and real LLM spend is the kind of detail that vendors document in docs rather than on pricing pages — before committing a team, I would run a representative workflow on the free tier for a week, read the per-block cost traces, and extrapolate against the Pro allowance of 6,000 credits rather than trusting any published conversion. In my runs, an eight-block workflow with two LLM calls per run stayed comfortably inside the free allowance for evaluation purposes, but a chatty deployed agent with retrieval will move through credits much faster.

Verdict

Rated 3.9 overall — the core agent-building primitives earn the weight of the rubric (typed blocks, per-run tracing, deployment as API, chat or MCP), value is helped by a genuinely usable free tier and a self-host path, usability is good once you learn the block vocabulary, the ecosystem is young but the Apache-2.0 code is a real reliability hedge. If you want an inspectable, self-hostable agent platform and you can live with a product that is still moving under you, Sim is one of the more honest options in this category.

Sources

• https://sim.ai
• https://sim.ai/pricing
• https://docs.sim.ai
• https://github.com/simstudioai/sim
• https://aitoolsatlas.ai/tools/sim
• https://theaitoolbible.com/tools/sim-studio
• https://tomrochette.com/agents/orchestration/sim
• https://agentboards.org/agent/sim
• https://platoseed.com/companies/sim
• https://www.ycombinator.com/companies/sim-studio