Sim: A Visual Agent Workflow Builder That Writes Its Own Flows

Most workflow builders ask you to figure out the graph yourself. You drag in a model block, wire it to a retrieval step, add a conditional router, realize the output format is wrong, unwire everything, and start over. Sim's pitch is that you can skip most of that loop: describe what you want in plain English, and its AI Copilot builds the wiring for you. When something still goes wrong — and in agent workflows, something always does — you get a full block-by-block execution trace with token counts and costs inline, not a wall of logs.

Sim has been in the "viral Twitter lists" rotation for months alongside Dify as a go-to example of no-code agent infrastructure that actually works. The comparison is fair in terms of popularity but the products point at different things. Here is what Sim actually is, and who should care.

At a glance

What Sim actually is

Sim is a visual canvas for composing AI agent pipelines. You drag in typed blocks — Start, Agent, Function, API, Router, Loop, Condition — and connect them into a flow diagram where each block feeds into the next. The canvas is Figma-like in feel: nodes, edges, a zoom-and-pan workspace. Each block exposes configuration on click: which model, which tools, what system prompt, what output format. The whole flow runs when you hit execute.

That is the canvas half. The other half is the AI Copilot: a chat interface in the sidebar where you describe what you want ("build me a workflow that reads a Slack message, checks our Notion database for relevant context, drafts a reply with GPT-4o, and asks me to approve it before sending") and Sim assembles the blocks and wires them together. You can then edit the result manually, re-describe a modified version, or ask the Copilot to change a specific block. The two modes — manual canvas and conversational generation — work on the same underlying graph, so you can mix them freely.

The third piece is observability. Sim traces every run block by block, with execution time, token usage, and real cost displayed for each step, not just the total. If your pipeline fails at step four of nine, you see exactly what the inputs were, what the model returned, and what the routing logic decided before everything went sideways. That level of detail is not common in visual builders at this price point.

What ships in the repo

The canvas primitives:

• Agent blocks — any LLM (large language model — the AI engine doing the reasoning) from any supported provider, with forced tool calls and dynamic tool selection; you can mix providers within one workflow
• Function blocks — JavaScript executed in an isolated sandbox (so custom code runs safely without touching your server), with full access to the block's input context
• API blocks — HTTP calls to any REST endpoint, with auth configuration and response mapping
• Router blocks — conditional branching on any field in the upstream output, with AI-powered routing as an option (the model decides which branch)
• Loop blocks — iterate over arrays, with configurable concurrency
• Knowledge Base blocks — semantic search over documents you upload, with vector indexing managed by Sim

Supporting infrastructure that ships alongside the builder:

• Tables — a lightweight built-in database you can read and write from within workflows
• Files — shared team storage accessible as block inputs
• Scheduled tasks — time-based triggers that fire a workflow on a recurring schedule (hourly, daily, weekly, or any custom interval)
• Logs — persistent run history with block-level traces, filterable by status, date, or workflow
• Webhooks — inbound HTTP triggers that kick off a workflow from an external event
• 1,000+ integrations — Slack, Notion, HubSpot, Salesforce, Google Sheets, GitHub, and many more, surfaced as block types or as tools available to Agent blocks

The whole thing is open-source under Apache 2.0, which means you can self-host it, modify it, and use it commercially with no restrictions.

Why this matters for ops and automation professionals

The core problem with every workflow builder is the gap between "I can describe the logic in English" and "I can express the logic in this tool's node graph." For someone who is not a developer, that gap is the entire adoption barrier. You understand what you want the automation to do. You do not necessarily know whether the router should go before or after the function block, or how to wire the output of a multi-turn Agent block into a conditional branch.

The AI Copilot is a serious attempt to close that gap. It does not just generate a template — it generates a runnable graph from your description, targeting your specific connected integrations and whatever LLM configuration you have already set up. Early user reports suggest it gets basic-to-moderate workflows right on the first pass and needs manual correction for more complex branching logic, which is an honest-enough starting position for any generative-layout feature.

The execution tracing matters for a different reason: debugging. Complex agent workflows fail in ways that are hard to reason about from logs alone. The block-level trace — showing you what the model actually received, what it returned, which tool it called with which arguments, and what the tool returned — turns a debugging session from a guessing game into a methodical walkthrough. For a legal ops manager or a growth analyst running an automated research pipeline, this is the difference between fixing a broken workflow in ten minutes and abandoning it.

The pricing structure is worth noting for small teams. The free tier is genuinely functional — 1,000 credits per month, 5 GB storage, 30-day log retention — not a hobbled demo. Pro at $25/user/month gets you 6,000 credits and 50-day log retention. Sim's credits cover the orchestration layer; you pay your LLM provider separately. That means cost is predictable and scales with actual use.

Where it fits

The honest answer is that visual agent builders have converged on a similar shape. The differentiator is usually which specific axis each tool treats as primary.

• Dify — the closest peer in terms of viral presence. Dify emphasizes RAG pipelines (retrieval-augmented generation — where an agent searches your documents before answering) and getting a polished chat-app UI into end users' hands quickly. Sim's emphasis is the agent graph and multi-model mixing, not the downstream consumer UI. If you are building an internal tool, Sim; if you are shipping a user-facing chatbot, Dify.

• n8n — the incumbent no-code automation platform with a vast integration library and a strong community of ops users. n8n is primarily an ops automation tool with AI features added; Sim is an AI workflow tool with ops integration added. The orientation is reversed. n8n also has commercial hosting restrictions that Sim's fully open-source license does not.

• Flowise — a visual builder with strong document-search (RAG) and human-approval support. Flowise was acquired by Workday in August 2025 and has since shifted toward enterprise deployment. The canvas is built around a specific AI framework (LangChain); Sim is more provider-neutral. For teams not already using that framework, Sim is easier to start.

• Langflow — a Python-based visual builder, best for teams that want to stay inside the LangChain ecosystem and have engineers involved. Sim targets a less technical builder and offers the AI Copilot as a substitute for needing that specialist knowledge.

Verdict

Install. Sim is the most complete no-code visual agent builder available right now for a non-developer who needs to compose LLM pipelines across multiple providers and integrations. The AI Copilot is a real differentiator — not a chatbot that outputs a configuration file you then have to decipher, but something that constructs a runnable graph you can then edit manually. The execution tracing is genuinely better than what comparable tools ship. The free tier is usable, the self-hosted path is real, and the Apache 2.0 license is the cleanest in this space.

The honest caveat: Sim is a v0.7.x product with an active release cadence. Complex branching logic and list-handling in workflows have rough edges the founders have publicly acknowledged. The AI Copilot is strong on common patterns and weaker on multi-level conditional routing. If your workflow is a straight shot from trigger to output, everything is smooth. If you are building something with three or four decision points and parallel branches, plan to spend time on the canvas manually rather than expecting the Copilot to nail it in one pass.

None of that is disqualifying. It is the honest state of a maintained, actively-developed project.

For your agent to install this

You can skip this section — it's the install details your AI agent needs. If you're using Cowork, Claude Code, ChatGPT Work, Codex, or Hermes, say "install Sim for me" and it will read the tables below.

System / OS requirements

API keys

Sim requires API keys from your LLM providers. It does not bundle any model credentials.

Additional integration credentials (Slack OAuth, Notion API key, HubSpot token, etc.) are configured per-block inside the Sim UI after install. Sim stores them encrypted.

Install commands

Cloud (fastest — no install):

Visit sim.ai and sign up. Free tier starts immediately with 1,000 monthly credits.

Self-hosted via CLI (requires Docker running):

npx simstudio

Then open http://localhost:3000.

Self-hosted via Docker Compose (pinned version):

git clone https://github.com/simstudioai/sim.git
cd sim
docker compose -f docker-compose.prod.yml up -d

Self-hosted manual (full dev setup with Bun):

git clone https://github.com/simstudioai/sim.git
cd sim
bun install
# Copy and configure environment variables
cp .env.example .env.local
# Start dev server
bun dev

The environment config file needs a database URL, an encryption key for stored credentials, and optionally a Trigger.dev token for background job execution. The repo README has the full variable list.

First-run

After install, create a workspace, add at least one LLM API key in Settings, and either open a blank canvas to start dragging blocks, or open the Copilot sidebar and type a description of the workflow you want. The Copilot generates a starting graph; click any block to configure details the Copilot left as defaults.