AgentSwarms

Deploy your own agentic AI & business-intelligence platform.
Build agents, run multi-agent swarms, ground them in your data, and inspect every trace — on your own infrastructure, with your own keys.

Screenshots · Features · Quickstart · Documentation · Self-host vs. hosted · Contributing

AgentSwarms is a self-hosted, source-available platform for running AI agents against your own data.

The agent side is what you'd expect: agent chat, a visual canvas for multi-agent swarms, knowledge bases with RAG (hybrid search, parent-child and Q&A indexing), MCP in both directions, batch evaluations, and execution traces with per-call costs. What's less usual is what sits underneath. A semantic layer holds your metric definitions, so an agent asked about revenue uses the same definition your finance team does instead of guessing at a column. The data catalog tracks lineage, so an answer can be traced back to the table it came from. Model rules, spend budgets and a hash-chained audit trail apply per user and per group, and they run before the call rather than reporting on it afterwards. Dashboards, alerts and scheduled reports read those same definitions.

Warehouses connect directly — Snowflake, BigQuery, Databricks, Redshift, Trino, ClickHouse, Oracle, SQL Server, Postgres and MySQL among them — alongside file uploads and SaaS sources like Stripe, Shopify and HubSpot.

Running it takes one Supabase project and one Docker command. Your data stays in that Supabase project, and models run on your own provider keys: OpenRouter, OpenAI, Anthropic, Gemini, Bedrock, Azure, OCI, Qwen, Grok, Groq, Ollama, vLLM. Set one instance-wide OpenRouter key and people can start without configuring a provider at all.

A look at it

Swarm canvas — design a multi-agent workflow as a graph and run it end to end. Each node is a step (agent, router, condition, loop, approval, tool call); the inspector sets its provider, model, prompt, tools and knowledge. The same graph runs from the canvas, from the API and on a schedule — the canvas edits a draft, and API keys and schedules keep serving the last published snapshot until you promote it.

AI Analyst — a dedicated conversational-analysis surface: create analysts (a reasoning model pinned to your data, nothing else to configure) that plan each question into steps, write and run the SQL, check their own work, and write up findings where every number cites its step. Every step gets its own chart, can be pinned to a dashboard or edited and re-run, and the whole trace exports as a branded PDF. Contribution analysis, trends, outliers and projections are computed in code rather than narrated — and it asks a clarifying question instead of guessing when one is genuinely needed.

BI Workspace — multi-page dashboards over your connected tables and warehouses, with KPIs, cross-filtering, scheduled refresh, PDF export and publish-and-share links.

Agent Chat, with Visual BI — ask a question in plain language and get a chart computed from your own data beside the answer. The SQL that produced it is shown as the source, so the number is checkable rather than asserted.

Agent Chat, generating documents — turn the conversation and your data into a real, editable PowerPoint, Word document or Excel workbook. The Excel can pull every row with live formulas rather than a pasted snapshot.

Developer workspace — Python notebooks on sandboxed server kernels with real langchain, langgraph and llama_index installed. Model and knowledge-base calls are brokered by the platform, so no provider key ever exists inside the sandbox. Notebooks can call your deployed agents, and can themselves be published as callable APIs.

This repo vs. agentswarms.fyi

Same UI, two different missions:

The "AgentSwarms" name and the hosted service remain with the project author.

Features

Quickstart

One-command setup — after you've created a Supabase project and put its keys in .env (see below), a script handles the rest (secrets, deps, migrations, and bringing up the stack):

cp .env.example .env      # fill in your Supabase keys, then:
bash scripts/setup.sh --all           # EVERYTHING  →  http://localhost:8080
# bash scripts/setup.sh               # core stack only (the app; optional services off)
# bash scripts/setup.sh --dev         # local dev server instead
# Windows PowerShell:  powershell -ExecutionPolicy Bypass -File scripts\setup.ps1 -All

Or do it by hand — there is no separate backend to install, since Supabase is the backend (Postgres + Auth + Storage), run as a free-tier hosted project rather than installing anything yourself:

git clone https://github.com/AgentSwarms-fyi/agentswarms.git
cd agentswarms
npm install
cp .env.example .env   # fill in your Supabase + provider keys
# apply the database schema once: npx supabase login && npx supabase link && npx supabase db push
npm run dev            # → http://localhost:8080

Self-host with Docker (any Node-capable host — VPS, Fly, Railway, Render, K8s):

cp .env.example .env   # fill in Supabase + keys, apply migrations once
docker compose --profile docgen --profile notebooks --profile sandbox up --build
# → http://localhost:8080   (plain `docker compose up --build` starts the app alone)

--all / the profile list above brings up the optional services too: the document renderer (native PowerPoint/Word/Excel), the JS sandbox (custom code in deployed swarm runs) and the Developer-workspace runtime (real Python kernels). They are separate profiles because each costs something — LibreOffice is a large image, and the notebook runtime needs Docker-socket access through a least-privilege proxy. Once up, Observability → Monitoring shows every service's health in one place.

First time? Follow the full installation guide — it covers every step on macOS, Linux, and Windows, including the Supabase dashboard clicks and a troubleshooting section for the errors people actually hit. Wondering what hardware you need (spoiler: a 2 vCPU / 4 GB VM, no GPU)? See System requirements & sizing.

"Does it handle billions of rows?" Aggregate queries compile to SQL that runs inside your warehouse, so table size is your warehouse's problem and only the grouped result travels. Anything that materialises locally is capped — local datasets at 500k rows, dashboard snapshots at 500 rows, warehouse result sets at 1,000 (5,000 hard ceiling). Every number, and the environment variable that changes it, is in Scale and limits.

Documentation

The docs live in docs/, one focused guide per topic:

Contributing

Contributions are welcome — see CONTRIBUTING.md for the workflow, and please read the Code of Conduct first.

Security

Found a vulnerability? Please see SECURITY.md for how to report it responsibly instead of opening a public issue.

License

AgentSwarms is source-available under the Elastic License 2.0 (ELv2). In plain terms: you may freely use, self-host, modify, and redistribute it — but you may not offer it to third parties as a hosted or managed service, and you may not remove the licensing/copyright notices. A separate commercial license is available from the author for use cases ELv2 doesn't permit (including running it as a SaaS) — reach out if that's you.

The "AgentSwarms" name, logo, and the hosted service are trademarks of the project author and are not licensed for your use; ELv2 covers the code, not the brand.

Every direct dependency uses a permissive license (MIT / Apache-2.0 / ISC / BSD), compatible with redistribution under ELv2 — the full audit and credits for the open-source projects AgentSwarms builds on live in ACKNOWLEDGEMENTS.md.