How to choose a self-hosted AI agent platform for a team

Agent Swarm is built by the team behind this blog.

The selection rule

Pick a team agent platform when several people need AI agents that share context and take work from the tools they already use. Pick a framework like LangGraph when you are building one agent into your own product. Pick a visual builder like Dify when the thing you ship is a chat or RAG app your customers open.

Team infrastructure is a different decision from a library or a personal assistant

Three properties define the category: shared context instead of a chat window that resets, work arriving from Slack or an API, and unattended runs with a gate where a person approves what matters.

A personal assistant is one agent for one person on one machine: OpenClaw runs an assistant on your own computer and meets you in the chat apps you already use, and Hermes Agent's README describes a built-in cron scheduler with delivery to any platform (October 26, 2026). A library is code you import: LangGraph and open-source CrewAI hand you primitives and leave you the deployment and the approvals. This page covers the third shape: infrastructure a team runs for itself. Our roundup of self-hosted agent platforms covers the full field, and shared context is the hard part covers the memory design behind this choice.

Six operating models

Agent Swarm. You deploy an API server and its worker containers, plus MinIO object storage for shared files; a lead agent turns goals into tasks for workers, each in its own Docker container; state lives in a SQLite volume with vector memory scoped to swarm and agent, plus a shared file volume. MIT license (October 26, 2026).

Paperclip. You deploy a Node server and a React UI over Postgres and supply agents through adapters such as Claude Code or Codex; agents fill an org chart that takes tickets, woken by heartbeat; state lives in Postgres. MIT license.

Dify. You deploy Compose with seven core services and eight dependent components; your team builds agents and RAG pipelines on a visual canvas and publishes apps that answer users; state lives in Postgres and the vector store. The modified Apache-2.0 license withholds multi-tenant operation without written permission and forbids removing the Dify logo.

LangGraph. You deploy nothing until you choose to: pip install langgraph puts a Python or TypeScript framework inside your own application, where agents are graphs of nodes you write; run state and memory live in the checkpointer and store you configure. The library is MIT, langgraph-api is source-available under Elastic-2.0, and self-hosted LangSmith is an Enterprise add-on (October 26, 2026).

CrewAI. The crewai package is an MIT Python library of role-playing crews and event-driven Flows that your code starts; state lives wherever your process keeps it, and AMP, the commercial control plane around it, offers cloud and on-premise.

n8n. You deploy a container and a database, or use n8n Cloud, and draw flows on a canvas with AI Agent nodes inside them; state lives in the n8n database. The Sustainable Use License makes n8n free for internal business use and not OSI open source.

The comparison

Cells were checked against each product's own repository or documentation on October 26, 2026. "Not documented" means the source is silent, not that the feature is absent.

Product	Shared context and memory	Worker isolation	Integrations	Schedules	Approvals and human-in-the-loop	Model and harness flexibility	Deployment ownership	License	Hardware floor	Maintenance burden
Agent Swarm	Swarm-scoped and agent-scoped vector memory, shared volume, shared file drive	One Docker container per worker	Slack, GitHub, GitLab, Azure DevOps, Linear, Jira, email, Sentry	Cron and interval schedules, delayed runs; targets tasks, workflows, scripts	Human-in-the-loop node that pauses a run	Claude Code, Codex, pi-mono, opencode, Devin, ACP	Yours: Compose, Helm, rootless Podman	MIT	2-4 vCPU, 4-8 GiB for one lead and one worker	Several containers and a database
Paperclip	Not built in; experimental Mem0, Zep, Supermemory, Cognee, Honcho connectors, off by default	Shared working tree by default; worktrees and sandboxes experimental	GitHub, Notion, Linear, Sentry, Gmail, custom MCP servers	Heartbeats and scheduled routines	Approval stages on tasks and on hires	Claude Code, Codex, Cursor, Gemini CLI, Pi, Kimi	Yours: Node server plus Postgres	MIT	1 vCPU and 2 GB RAM	One Node service and a database
Dify	Per-app conversation variables and knowledge bases; no cross-agent team memory documented	Sandbox container for code; apps share API and worker containers	Plugin marketplace; API per published app	Schedule and webhook triggers	Human Input node pauses a workflow	Models from dozens of providers	Yours: Docker Compose	Modified Apache-2.0, no multi-tenant service without permission	2 CPU and 4 GiB	Seven core services and eight dependent components
LangGraph	Checkpointer for thread state, store for long-term memory; you wire both	None provided; you deploy the runtime	Whatever you code, plus LangChain integrations	Not documented; scheduling is yours to build	Interrupts as a primitive for human review	Any model your client code can call	Yours: your application; managed runtime is Enterprise-only	MIT library, langgraph-api under Elastic-2.0	Not documented	The whole system, because you build it
CrewAI	Short-term memory plus long-term and entity memory in the library; storage is yours	None; runs inside your process	Tool library and MCP; AMP adds connectors	Not documented; bring an external scheduler	Human input in Flows; AMP adds checkpoints	Any LLM your code can call	Yours: your Python app; AMP is vendor-deployed	MIT library, AMP commercial	Not documented	Your application; AMP is vendor-supported
n8n	Instance variables and data tables, plus chat memory nodes	Executions share the instance; queue mode adds workers	1,500+ integrations, 9,000+ templates per the README	Schedule trigger	Human approval for tool calls (n8n pricing page)	Any chat model node, with your own keys	Yours: Docker or npm; or n8n Cloud	Sustainable Use License, not OSI	No general floor documented; the OEM sizing page lists 320 MB to 2 GB	One service and a database, plus the flows you draw

Where Agent Swarm fits

Agent Swarm fits when the agents are the product, not a feature inside one. A lead agent takes a standing queue of work and delegates it to a team of workers in isolated Docker containers that read one shared memory and keep their identity across sessions. Schedules fire recurring work, and the DAG workflow engine carries multi-step processes with a human-in-the-loop node that pauses for approval. Harnesses include Claude Code, Codex, pi-mono, Devin, plus any ACP-compatible runtime, so a team can mix vendors.

Work arrives from Slack, Linear, GitHub, GitLab, Jira, email, Sentry, and every task lands in one inspectable graph. The license is MIT. Install with bunx @desplega.ai/agent-swarm onboard, a Docker Compose file, a Helm chart or rootless Podman; start at the getting-started guide. Multi-agent orchestration patterns shows the structure before you write orchestration code, and /security covers deployment posture.

Where another option is better

Dify wins when the deliverable is an app people open: a RAG assistant or a workflow the business team can edit without a pull request. LangGraph wins when one agent lives inside your product, because a framework you embed beats a system you operate. Paperclip wins when the org-chart model is what you want: budgets, reporting lines, an approval step on every hire. n8n wins when the work is deterministic plumbing between SaaS tools and must run the same way every time.

To compare two of them, start at the comparison hub and open /vs/dify, /vs/langgraph, /vs/paperclip, /vs/crewai or /vs/n8n.

When a single agent or a framework is enough

One person in one repository with no unattended work does not need this category. If shared memory, schedules and approvals do not describe your team, start with one agent.

Honest limits

Agent Swarm is a multi-container stack, not a single binary: the reference deployment runs an API server, object storage, a lead agent and its workers, and the sizing guide starts at 2-4 vCPU and 4-8 GiB for one lead and one heavy worker (verified October 26, 2026). It also has the smallest community of the six, at 946 GitHub stars against 159,593 for Dify and 107,518 for Paperclip on the same day.

We do not claim Agent Swarm is right for every team. It fits a team that wants a standing swarm with shared memory and will run the containers. If you want a canvas or a library, another product here serves you better.

Sources

Each claim traces to one of these pages or to a source named inline in the text or table. All checked October 26, 2026.

• Agent Swarm: repository and README, license, resource sizing
• Paperclip: README, installation, memory connectors, isolated workspaces, connector catalog
• Dify: README, license, Docker Compose deployment
• LangGraph: README, langgraph-api on PyPI, self-hosted LangSmith
• CrewAI: README, license, memory, pricing, deploy to AMP
• n8n: README, Sustainable Use License, choose how to use n8n, pricing, OEM prerequisites
• Personal assistants: OpenClaw README, Hermes Agent README
• Star counts: each project's GitHub repository page, October 26, 2026.