# AgentSwarms – self-hostable agentic AI/BI platform with sandboxed Python (ELv2)

> Source: <https://github.com/AgentSwarms-fyi/agentswarms>
> Published: 2026-07-29 22:14:05+00:00

**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](#a-look-at-it) ·
[Features](#features) ·
[Quickstart](#quickstart) ·
[Documentation](#documentation) ·
[Self-host vs. hosted](#this-repo-vs-agentswarmsfyi) ·
[Contributing](/AgentSwarms-fyi/agentswarms/blob/main/CONTRIBUTING.md)

**AgentSwarms** is a complete, self-hostable, **source-available** agentic AI &
business-intelligence platform: agent chat, a visual multi-agent swarm canvas,
knowledge bases with RAG, tool use, MCP connections, connected databases &
warehouses, dashboards, budgets, and full execution traces. It is designed for
**easy deployment**: one Supabase project as the backend, one Docker command to
run, and **bring-your-own-everything** — your data lives in your own Supabase
project, and models run against your own provider keys (OpenRouter, OpenAI,
Anthropic, Gemini, Bedrock, Azure, OCI, Qwen, Grok, Groq, Ollama, vLLM…).
Optionally set one instance-wide OpenRouter key so every user on your
instance can start with zero setup.

**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.

**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.

Same UI, two different missions:

This repository (source-available, Elastic License 2.0) |
|
|
|---|---|---|
Focus |
Easy deployment of the full agentic AI & BI platform on your own infrastructure — agents, swarms, RAG, connected data, dashboards, traces, budgets. |
Learning first: a hands-on classroom for agentic AI — guided curriculum, build-along labs, interactive notebooks, presentations, and certification — fully managed. |
Runs on |
Your Supabase project, your provider keys, your Docker host (or Cloudflare Workers). | Managed infrastructure, including an AI gateway with free-tier models — nothing to configure. |
Extras |
Headless control of your own data; no usage caps other than your own budgets. | Hosted-only surfaces: field-engineering blog, community galleries, voice agents, website embeds, and free standalone tools. |
Best for |
Teams and tinkerers who want to run an agentic AI platform they own. |
Learners who want to study and practice agentic AI without setting anything up. |

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

🤖 Agent Chat |
Build an agent, wire up tools, and chat with it in-browser (under Build → Agent Chat), with full request/response traces. Flip on Visual BI to render a chart from your connected tables next to the answer, and generate a fully-editable PowerPoint, Word or Excel from your prompt + the conversation — the Excel can pull all rows with live formulas. See .
|
🐝 Swarm canvas |
Design multi-agent workflows visually (built on
checkpoint as they go, so a run survives a restart or deploy, and a human-approval step parks the run until someone decides rather than rubber-stamping it or failing. |

**Knowledge Base / RAG****Data Sources****PostgreSQL**(Supabase, RDS, Neon…),** MySQL/MariaDB**,** Oracle**(Autonomous DB / ORDS), Amazon Redshift, Snowflake, Databricks, Google BigQuery, Azure Synapse,** Trino / Starburst / Presto**, and** Amazon Athena**— encrypted credentials, read-only. Query them from the Data Catalog SQL workbench, from SQL agents, and feed BI charts, ontologies and scheduled refreshes. See**.**[Data sources & connectors](/AgentSwarms-fyi/agentswarms/blob/main/docs/DATA_SOURCES.md)** Secrets Manager**`{{secret:NAME}}`

— warehouse connections, provider keys. Superadmins share secrets with users/groups via IAM.**Data Catalog****Iceberg REST catalog** through a wizard; the crawler lists every table and object, groups partitioned folders into datasets, infers CSV/JSON schemas by sampling, profiles columns (null %, distinct counts, ranges), estimates row counts, and flags likely-PII columns. Schedule daily/weekly incremental crawls with schema-drift notifications, generate asset + column documentation with AI, certify or deprecate assets with owners and tags, trace lineage and usage (which dashboards, prep flows and metrics consume each table), define a business glossary, and jump straight into the SQL workbench.**Business Intelligence****workspaces & folders** with read-only group sharing,**promote** a personal draft into a shared workspace, and**export** model/dashboard definitions to a**Git** repo (GitHub/GitLab).**Observability****Web search & browsing**`web_search`

and `web_browse`

tools. Works out of the box with **no key**(free DuckDuckGo fallback — limited); for real workspace-wide search + full-page reads, connect** Firecrawl**on the Integrations page (or set`FIRECRAWL_API_KEY`

), or bring your own **Brave / SerpAPI / Tavily / ScrapingBee** key per agent. Every model-driven fetch is SSRF-guarded. See**.**[Web search & browsing](/AgentSwarms-fyi/agentswarms/blob/main/docs/INSTALL.md#web-search--browsing-optional)** BYOK + MCP + A2A****MCP Builder****FastMCP** under**Build → MCP Builder**, deploy it to the same sandboxed kernel the Developer workspace uses, and get a real Streamable-HTTP endpoint. It scales to zero by default (or stays warm), registers itself so your own agents can call it, and can be**exposed publicly** with hashed API keys that support expiry, per-tool and per-IP limits. Secrets bind as environment variables without ever entering the container environment, and a redeploy that changes any tool name, description or schema**blocks calls until you re-approve**— the anti "rug pull" control MCP's own security guidance asks for. Needs the server runtime enabled.** IAM****Developer workspace****sandboxed server kernels**— real CPython with working`pip install`

and genuine **LangChain**,** LangGraph**and** LlamaIndex**imports, not a browser emulation. Ships with read-only, runnable samples for each plus a mixed agentic-stack capstone (knowledge base, tools, skills, guardrails, MCP) — fork any of them to edit. The built-in`agentswarms`

helper calls your connected models, searches your knowledge base and **runs your saved agents and swarms**, all governed by IAM rules and logged in Traces — no provider key ever exists inside the sandbox. A notebook can also be**published as a callable API**, and versioned to Git as plain Python. Operators enable the runtime under** Admin → Developer runtime**; see**.**[the runtime guide](/AgentSwarms-fyi/agentswarms/blob/main/docs/DEVELOPER_WORKSPACE_RUNTIME.md)** Guardrails & evals****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                 # Docker stack  →  http://localhost:8080
# bash scripts/setup.sh --dev         # local dev server instead
# bash scripts/setup.sh --docgen      # + server-side PowerPoint / Word / Excel renderer
# Windows PowerShell:  powershell -ExecutionPolicy Bypass -File scripts\setup.ps1
```

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 up --build
# → http://localhost:8080
```

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.

The docs live in [ docs/](/AgentSwarms-fyi/agentswarms/blob/main/docs), one focused guide per topic:

| Guide | What it covers |
|---|---|
|
Complete local setup on macOS / Linux / Windows: prerequisites, Supabase project, environment variables, first run, and troubleshooting. |
|
Every path: local desktop, a single cloud VM (OCI/AWS/GCP), autoscaled VMs behind a load balancer, Cloudflare Workers, and Kubernetes — plus TLS, scheduling/cron, health checks, backups, and PWA install. |
|
Chatting with a saved agent, per-agent Visual BI answers, and generating fully-editable PowerPoint / Word / Excel from your prompt (with Sample vs. full-data scope and live Excel formulas) — plus embedding an agent on your own site. |
|
Every database / warehouse / lakehouse connector (PostgreSQL, MySQL, Oracle, Redshift, Snowflake, Databricks, BigQuery, Synapse, Trino, Athena): fields, the read-only + encrypted-credential model, `{{secret:NAME}}` references, and how sources feed the catalog, BI and agents. |
|
Dashboards and the AI analyst: 19 visual types incl. the AI-built ontology, drill-down & forecasting, scheduled refresh + data alerts, AI-generated dashboards, workspaces & folders, dev→prod promotion, Git export, publishing / embedding / export, data prep, and connectors. |
|
Governed metrics + dimensions defined once and consumed by both BI and AI agents (the `metric_query` tool), so business definitions compute consistently and the AI picks names instead of writing SQL. |
|
Superadmins, groups, user provisioning, model allow-lists, read-only resource sharing, invite-only mode, and SAML SSO. |
|
Standing up the sandboxed Python kernels behind notebooks: the Docker/Kubernetes/E2B backends, the threat model and hardening, the egress allow-list, and how model and knowledge-base calls are brokered so no key reaches the sandbox. |
|
Adding skills (markdown `skill.md` capabilities, no code) and built-in tools (definition + handler + gate in the registry), plus how tool-routing guidance keeps source selection sane. |
|
Tech stack and project structure. |

Contributions are welcome — see ** CONTRIBUTING.md** for
the workflow, and please read the

**first.**

[Code of Conduct](/AgentSwarms-fyi/agentswarms/blob/main/CODE_OF_CONDUCT.md)Found a vulnerability? Please see ** SECURITY.md** for how
to report it responsibly instead of opening a public issue.

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**.

Built with TanStack Start and Supabase — an agentic AI & BI platform you own.