|

SIM Review: Build and Deploy AI Agent Workflows in Minutes (Cloud or Self-Hosted)

ByInnoVirtuoso

If you’ve been hunting for a practical way to build AI agent workflows without spending weeks wiring up tools, models, and infrastructure, SIM might be the framework you’ve been waiting for. It’s fast. It’s visual. And unlike many platforms, it gives you flexibility: run it in the cloud at sim.ai or self-host it with Docker, Bun, and PostgreSQL. Even better, you can run local models with Ollama—no external API calls required.

In this hands-on review, I dig into what SIM is, who it’s for, how it works under the hood, and exactly how to set it up. I’ll cover the cloud experience, every self-hosted path (including Ollama), and the developer workflow. By the end, you’ll know whether SIM belongs in your stack—and how to get real agents running today.

Let’s start at the top.

What Is SIM?

SIM is an open-source platform for building, testing, and deploying AI agent workflows. Think: a visual flow editor for multi-step automations, with real-time sockets for collaboration and execution, a knowledge base powered by vector embeddings, and an approachable developer experience built on modern tools.

  • Cloud-hosted: Use sim.ai to get started fast.
  • Self-hosted: Run via NPM, Docker Compose, Dev Containers, or manual setup with Bun and PostgreSQL.

Here’s why that matters: many teams want AI agent capabilities but need control—over data, over infrastructure, and over cost. SIM’s architecture makes that tradeoff easy. You get the cloud convenience or fully local autonomy (including local LLMs with Ollama).

Key Features That Stand Out

  • Visual Flow Editor (ReactFlow): Build agent workflows as a graph. Drag, drop, and connect nodes. Great for non-linear logic and multi-agent patterns.
  • Realtime Collaboration and Execution: Backed by Socket.io for live updates and event streaming.
  • Knowledge Base + Vector Search: Uses pgvector with PostgreSQL for embeddings and semantic search.
  • Local AI with Ollama: Run models like Gemma and Llama locally (CPU or GPU) so you can keep data on-prem and avoid API costs.
  • Modern Web Stack: Next.js (App Router), Bun runtime, Drizzle ORM for migrations, Tailwind CSS, shadcn/ui, and Zustand for state.
  • Background Jobs: First-class support via Trigger.dev.
  • Authentication: Powered by Better Auth.
  • Monorepo with Turborepo: Streamlined builds and developer ergonomics via Turborepo.

From a developer’s perspective, the stack feels modern and sane. From a product perspective, the combination of visual flows + local models is what makes SIM compelling.

Who Is SIM For?

  • Product teams prototyping AI assistants and automations.
  • Data and platform teams needing on-prem or VPC-compliant agents.
  • Startups that want fast iteration without lock-in.
  • AI engineers who prefer building with real-time feedback and an editable graph editor rather than monolithic scripts.
  • Anyone who wants to try local-first AI with Ollama, vector search, and a visual editor.

If you’re allergic to heavy backend scaffolding or rigid SaaS constraints, SIM is refreshingly flexible.

Cloud vs. Self-Hosted: What to Choose

  • Choose Cloud (sim.ai) if you want:
  • The fastest path to value
  • Zero infrastructure overhead
  • A clean space to experiment and collaborate
  • Choose Self-Hosted if you need:
  • Full control over data and models
  • Local models (no external APIs)
  • Private deployments or air-gapped environments
  • Custom authentication, routing, or storage

You can always start in the cloud and migrate later.

The Tech Stack, Explained (in Plain English)

  • Next.js (App Router): Production-grade React framework for the front end and server routes. Learn more at nextjs.org.
  • Bun Runtime: A blazing-fast JavaScript runtime, package manager, and test runner. See bun.sh.
  • PostgreSQL + pgvector: A relational database with embeddings superpowers via pgvector. This is how SIM powers knowledge bases and semantic search.
  • Drizzle ORM: Type-safe database migrations and query builders. See orm.drizzle.team.
  • Socket.io: Live updates and real-time execution. Great for long-running agent tasks and collaborative editing.
  • Trigger.dev: Background jobs that are reliable and observable.
  • UI/State: Tailwind CSS, shadcn/ui, and Zustand for a responsive, maintainable front end.
  • Monorepo and Docs: Turborepo for dev speed and Fumadocs for docs.

The upshot: SIM isn’t a black box. It’s an open, modern web app you can understand and extend.

How to Get Started (Cloud)

The easiest way to try SIM is to visit sim.ai. Create an account, start building flows, and test agent runs in minutes. If you just want to validate your use case or demo something to your team, this is a no-brainer.

When you’re ready for full control, go self-hosted.

How to Self-Host SIM (Four Paths)

Below are the four primary ways to run SIM locally or in your own environment. Pick the one that matches your comfort level.

1) NPM Quickstart (Docker required)

Requirements: – Docker installed and running

Run:

npx simstudio
# Optional flags:
#   -p, --port <port>    Port to run Sim on (default 3000)
#   --no-pull            Skip pulling latest Docker images

Then open http://localhost:3000

This is the “it just works” local experience.

2) Docker Compose (Production-style)

Clone the repo and bring it up with a production Compose file:

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

Then open http://localhost:3000

This is a good choice if you want a reproducible deployment target for servers or CI/CD.

3) Use Local Models with Ollama (No External APIs)

Run SIM with Ollama so models stay local:

  • With GPU (auto-downloads gemma3:4b):
docker compose -f docker-compose.ollama.yml --profile setup up -d
  • CPU-only:
docker compose -f docker-compose.ollama.yml --profile cpu --profile setup up -d

Wait for the model to download, then open http://localhost:3000

Add more models:

docker compose -f docker-compose.ollama.yml exec ollama ollama pull llama3.1:8b

Why this matters: You can run meaningful agent workflows without sending data to a third-party LLM API. This is a big win for privacy and cost control.

4) Dev Containers (VS Code)

If you use VS Code with the Remote – Containers extension, this setup is clean:

  • Open the project in VS Code.
  • Click “Reopen in Container” when prompted.
  • Start the full dev stack:
bun run dev:full
# or use the alias:
sim-start

This brings up both the main app and the realtime socket server.

Manual Setup (For Power Users)

If you want full control or want to develop against the codebase locally, here’s the manual path.

Requirements: – Bun – PostgreSQL 12+ with the pgvector extension

Clone and install:

git clone https://github.com/simstudioai/sim.git
cd sim
bun install

Spin up PostgreSQL with pgvector (recommended via Docker):

docker run --name simstudio-db \
  -e POSTGRES_PASSWORD=your_password \
  -e POSTGRES_DB=simstudio \
  -p 5432:5432 -d \
  pgvector/pgvector:pg17

Configure environment:

cd apps/sim
cp .env.example .env
# Set:
# DATABASE_URL="postgresql://postgres:your_password@localhost:5432/simstudio"
# BETTER_AUTH_SECRET=...
# BETTER_AUTH_URL=...

Migrate the database:

bunx drizzle-kit migrate

Start development servers (recommended all-in-one from project root):

bun run dev:full

Or run separately:

  • Next.js app:
bun run dev
  • Realtime socket server:
cd apps/sim
bun run dev:sockets

Finally, open http://localhost:3000

Copilot API Keys (for Self-Hosted)

SIM’s Copilot is a managed service. To enable it on your self-hosted instance:

  1. Go to sim.ai → Settings → Copilot
  2. Create a Copilot API key
  3. Set COPILOT_API_KEY in your self-hosted environment

This lets you keep your instance local while still leveraging Copilot where needed.

Building Your First Agent Workflow (Example)

Let’s walk through a simple agent that: 1) Takes a customer question, 2) Searches your knowledge base, 3) Drafts an answer, 4) Sends it to a review step, 5) Posts to Slack (or another channel).

High level steps: – Create a new flow in the visual editor. – Add nodes: Input → Retrieve Knowledge → LLM Draft → Human Review → Send Message. – Configure vector search by pointing to your knowledge base (SIM uses PostgreSQL + pgvector). – If you’re using Ollama, select your local model (e.g., gemma3:4b or llama3.1:8b). – Configure your outgoing channel (webhook, Slack, email—whatever you use). – Run the flow and watch the real-time execution via Socket.io events.

Tips: – Keep prompts small and explicit. Chain simple steps rather than one mega-prompt. – Use embeddings for context instead of dumping entire documents into prompts. – If you need approvals, add a Human-in-the-Loop step and capture review notes. – Use Trigger.dev for long-running tasks or scheduled jobs.

Here’s why that matters: AI agents are only as good as the structure around them. The flow editor helps you design that structure clearly.

Performance and Scaling Considerations

  • Ports and Processes: By default, SIM runs on port 3000. The real-time socket server is a separate process in dev mode—ensure both are running for full functionality.
  • Database: Use PostgreSQL 12+ with pgvector. If you ingest lots of data, index your vector columns and tune memory.
  • Models:
  • Local: If you use Ollama with CPU, start with smaller models (e.g., Gemma 2B–4B variants). For speed, enable GPU and use 7B–8B where possible.
  • Hosted: If you opt for external APIs later, make sure your rate limits and retries are configured.
  • Background Jobs: Delegate long-running or scheduled steps to Trigger.dev to keep your UI responsive.
  • Caching: Cache embeddings and retrieved chunks when possible to reduce repeated work.

If you’re deploying in production, treat SIM like any Next.js app: – Place behind a reverse proxy. – Add observability (logs, traces). – Harden secrets and environment variables.

Security and Data Governance

  • Local-first option: Running SIM with Ollama keeps sensitive text on your hardware. This is ideal for regulated teams.
  • Database isolation: Keep your PostgreSQL and vector indexes inside your VPC. Rotate credentials regularly.
  • Authentication: SIM uses Better Auth; configure provider settings and session lifetimes to match your policies.
  • Principle of least privilege: Scope your database users appropriately.
  • Secret management: Store API keys and secrets in your orchestration layer or a secret manager, not in code.

No platform removes the need for good security hygiene. SIM just gives you the levers to do it right.

How SIM Compares to Alternatives

  • LangGraph / LangChain tooling: Great for code-centric agent graphs. SIM is stronger if you want a visual UI, real-time execution, and a turnkey app you can share with non-developers.
  • LangFlow: Also visual, with a node/graph approach. SIM’s modern web stack, embeddings with pgvector, and real-time features feel more production-minded for teams ready to ship.
  • AutoGen Studio / CrewAI UIs: Similar multi-agent goals. SIM’s local models via Ollama and clean self-hosting story stand out for data-sensitive teams.
  • Open WebUI: Excellent for chat with local LLMs. SIM is broader: it aims at full workflows, knowledge bases, and background jobs.

Bottom line: SIM shines when you want a visual builder, real-time visibility, a strong self-host story, and local models—without building your own scaffolding.

Pros and Cons

Pros: – Flexible deployment: cloud or fully self-hosted. – Local models via Ollama—no external API required. – Visual editor plus real-time execution makes debugging easier. – Modern, open tech stack that’s easy to extend. – Built-in vector search with pgvector. – Background jobs with Trigger.dev.

Cons: – Requires Docker familiarity (for most self-hosted paths). – PostgreSQL with pgvector is a must for embedding-based features. – CPU-only local models can be slow; a GPU is recommended for larger models. – You’ll still need to bring your own operational practices for production (scaling, backups, observability).

Contributing and Community

SIM is open-source. If you want to help shape the roadmap, start by exploring the repo:

Open a PR, file an issue, or share a template flow. The project benefits from real-world examples.

Troubleshooting: Common Gotchas

  • “I can’t reach http://localhost:3000”
  • Ensure the container is running: docker ps
  • Check logs: docker compose logs -f
  • If port 3000 is used, run with --port 3001 and visit that port.
  • “Migrations fail with pgvector errors”
  • Verify you’re using the pgvector/pgvector PostgreSQL image or have installed the extension manually.
  • Run CREATE EXTENSION IF NOT EXISTS vector; in your DB if needed.
  • “Ollama model downloads are slow or stuck”
  • Check network connectivity and available disk space.
  • Use smaller models first (gemma 2–4B) to test the pipeline.
  • Confirm the compose service for ollama is healthy.
  • “Realtime events aren’t appearing”
  • Ensure the socket server is running (in dev: bun run dev:full).
  • Check any reverse proxy config that may block websockets.
  • “Auth isn’t working locally”
  • Verify BETTER_AUTH_SECRET and BETTER_AUTH_URL in .env.
  • Restart after env changes.

FAQ: People Also Ask

Q: What is SIM used for?
A: SIM is used to design and run AI agent workflows. You can build multi-step automations, connect to knowledge bases with embeddings, and execute flows in real time—either in the cloud or on your own infrastructure.

Q: Can I run SIM without external LLM APIs?
A: Yes. With Ollama, you can run local models like Gemma and Llama. This keeps data on your hardware and avoids per-token API costs.

Q: Do I need a GPU?
A: No, but it helps. CPU-only works for smaller models and prototyping. For production or larger models (7B–8B+), a GPU is strongly recommended.

Q: What database does SIM require?
A: SIM uses PostgreSQL 12+ with the pgvector extension for vector embeddings. You can run it via Docker or install pgvector manually.

Q: Is SIM open-source?
A: Yes. The code is available at github.com/simstudioai/sim.

Q: How does SIM compare to LangFlow?
A: Both offer visual graph builders. SIM’s strengths include a modern web stack, real-time socket features, and a straightforward self-host path with local models and pgvector-backed search.

Q: Can teams collaborate in real time?
A: Yes. SIM uses Socket.io for real-time updates, which helps with collaborative editing and monitoring flow runs.

Q: How do I add knowledge to an agent?
A: Ingest documents into SIM so they’re embedded into PostgreSQL via pgvector. Your agent can then use semantic search to fetch relevant chunks during runs.

Q: Does SIM support background jobs?
A: Yes. SIM integrates with Trigger.dev for reliable background and scheduled tasks.

Q: How do I enable Copilot in self-hosted mode?
A: Generate a Copilot API key at sim.ai → Settings → Copilot and set COPILOT_API_KEY in your environment.

Final Verdict

SIM delivers where many AI tools stumble: clear workflows, real-time visibility, and deployment flexibility. You can prototype in the cloud at sim.ai, then self-host with Docker and PostgreSQL when you’re ready to scale—or keep everything local with Ollama. The modern stack (Next.js, Bun, pgvector) makes it approachable for developers, while the visual flow editor opens the door for product and ops teammates.

Actionable takeaway: If you need production-minded agent workflows with control over data and models, spin up SIM locally today. Start with the NPM quickstart, try a small local model, and build a simple end-to-end flow. If it clicks, graduate to Docker Compose and a GPU-accelerated Ollama setup.

Want more deep dives like this? Subscribe or keep exploring—next, I’ll share a step-by-step template for building a customer support agent with local RAG and human-in-the-loop review.

Discover more at InnoVirtuoso.com

I would love some feedback on my writing so if you have any, please don’t hesitate to leave a comment around here or in any platforms that is convenient for you.

For more on tech and other topics, explore InnoVirtuoso.com anytime. Subscribe to my newsletter and join our growing community—we’ll create something magical together. I promise, it’ll never be boring! 

Stay updated with the latest news—subscribe to our newsletter today!

Thank you all—wishing you an amazing day ahead!

Read more related Articles at InnoVirtuoso

InnoVirtuoso

Hello there! I'm passionate content writer navigating the digital landscape. With a deep love for words and an insatiable curiosity about technology.

With 10 years of experience in IT field, I write mostly about emerging tech, sharing news, informational articles and covering other topics I find interesting.

Let's craft the future of content together – one word at a time!

Browse InnoVirtuoso for more!