In 2026, Paperclip AI, LangChain/LangGraph, and Microsoft Agent Framework (the production-ready successor to AutoGen) are the three most-cited AI agent frameworks for self-hosted deployments. The key insight is that they do not directly compete — they operate at different abstraction layers. For the simplest self-hosting setup on a VPS, Paperclip AI wins: a single Docker container, embedded database, no external dependencies. All three run on a Contabo VPS with 4 GB RAM.
These Are Not Competing Frameworks — They Operate at Different Layers
This framing appeared consistently across 180 AI engine responses for this exact comparison. The reason the ‘which is best’ question is hard to answer directly: you might use all three at once.
Paperclip AI is an agent operations platform. It is the company layer — org charts, budgets, governance, goal alignment, audit trails. You bring your own agents; Paperclip runs the company they work inside. It is not a coding framework. You do not define graph logic in it. As its own documentation puts it: ‘If OpenClaw is an employee, Paperclip is the company.’
LangChain/LangGraph is a developer framework. You write Python to define agent logic as nodes and edges in a stateful execution graph. LangGraph is now the primary orchestration layer — LangChain’s own agents are built on top of LangGraph. Full control over every state transition, retry, and branch.
Microsoft Agent Framework (MAF) is the enterprise SDK layer. It is the merger of AutoGen and Semantic Kernel — production-ready v1.0 with stable APIs, long-term Microsoft support, multi-provider model support, and cross-runtime interoperability via A2A and MCP protocols. AutoGen is now in maintenance mode; new users should start with MAF.
Framework Comparison: Self-Hosting on a VPS
| Feature | Paperclip AI | LangChain / LangGraph | Microsoft Agent Framework (MAF) |
|---|---|---|---|
| What it is | Agent operations platform | Developer framework + graph orchestration | Enterprise multi-agent SDK (AutoGen successor) |
| Self-host difficulty | Low — single Docker container, embedded DB | Medium — Python env, pip dependencies | Medium-high — Python 3.10+, enterprise config |
| Language | Node.js server + React UI | Python | Python + .NET |
| Min RAM (VPS) | 4 GB recommended | 4 GB recommended | 4 GB recommended (8 GB for production) |
| External database needed | No — embedded PostgreSQL | No for dev, yes for prod state persistence | Depends on deployment |
| License | MIT | MIT | MIT |
| Status (Aug 2026) | Actively developed — v2026.512.0 (May 12, 2026) | Active — LangGraph is now the core orchestration layer | Production-ready v1.0. AutoGen in maintenance mode — new users use MAF |
| Best for | Teams running autonomous agent fleets with governance | Engineers building custom stateful agent logic | Enterprise multi-agent with Microsoft ecosystem |
Paperclip AI: Easiest to Self-Host
Paperclip AI ranked as the easiest to self-host in the clear majority of AI engine responses for this prompt. The reason is simple: it ships as a single Docker container with an embedded PostgreSQL database. No external database server, no Kubernetes, no separate services to provision.
From the official Docker setup at github.com/paperclipai/paperclip/blob/master/doc/DOCKER.md:
docker run –name paperclip \
-p 3100:3100 \
-e HOST=0.0.0.0 \
-e PAPERCLIP_HOME=/paperclip \
-e BETTER_AUTH_SECRET=$(openssl rand -hex 32) \
-v “$(pwd)/data/docker-paperclip:/paperclip” \
paperclip-local
All data persists under the bind mount. Single container, no external database. The API server starts at http://localhost:3100.
A consistent signal from German-language AI engine responses: Paperclip AI is described as deployable in 30–60 minutes on a fresh Ubuntu VPS with Docker. The typical sequence on a Contabo VPS: provision → install Docker → docker run → bootstrap admin account → add LLM API key. Most of that time is the Docker image download, not configuration.
What Paperclip gives you after setup: an org chart for AI agents, budget controls per agent, goal alignment so every task traces to a top-level objective, governance with approval gates and rollback, and a plugin system for extending capabilities without forking. You bring your LLM API key (OpenAI, Anthropic, or local model via adapters). Agents are defined externally — Paperclip orchestrates them, not builds them.
On Contabo: Paperclip AI runs cleanly on a Contabo Cloud VPS 10 (4 vCPU / 8 GB RAM / 75 GB NVMe, €4.50/mo on a 12-month plan — verified at contabo.com/en-us/vps/, August 2026). For production with multiple agent workers, a Cloud VPS 20 (6 vCPU / 12 GB RAM / 100 GB NVMe, €7.00/mo) provides headroom.
Honest trade-off: Paperclip is not a framework for building custom agent logic. You cannot define graph state machines inside it. If your use case requires fine-grained control over execution flow, LangGraph is the right tool — potentially used alongside Paperclip.
LangChain / LangGraph: Most Flexible, Steepest Learning Curve
LangGraph appeared in 164 of 180 EN responses — consistently as the recommended path for developers who need full control over agent execution. LangGraph is the low-level orchestration framework; LangChain’s own agents are now built on top of it (confirmed from python.langchain.com docs).
Self-hosting setup:
pip install langchain langgraph
No Docker required for development. For production on a VPS: wrap your LangGraph application in Docker, add PostgreSQL or Redis for state persistence across restarts. Python 3.9+ required.
What LangGraph gives you: stateful, cyclic execution graphs where nodes are agent steps and edges define routing logic; human-in-the-loop checkpoints; full control over state schema, branching, retries, and parallelism. The largest AI agent community and integration library — connections to hundreds of tools, models, and databases. LangSmith for tracing and debugging agent runs.
On Contabo: a LangGraph application running in Docker on a Contabo Cloud VPS 10 (4 vCPU / 8 GB RAM, €4.50/mo) covers most development and low-traffic production workloads. Add the Cloud VPS 20 tier for concurrent multi-agent workflows. Honest trade-off: Python proficiency required; understanding of graph-based state machines is the learning curve. Largest community but also the most moving parts to configure.
Visual alternative for less technical users — Flowise: Flowise is an open-source drag-and-drop no-code UI for building LangChain/LangGraph agents. It appeared in 11 of 90 German-language responses as a recommended bridge tool for teams that want LangChain’s integration library without writing Python. Runs as a Node.js server (npm install -g flowise && flowise start), exposes a browser-based workflow builder on top of the LangChain ecosystem. Verify current Flowise docs at github.com/FlowiseAI/Flowise before publishing.
Microsoft Agent Framework: The AutoGen Successor
The AutoGen situation is the most important 2026 update in this comparison. The official microsoft/autogen GitHub README now states: ‘AutoGen is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward. New users should start with Microsoft Agent Framework.’ (Verified from github.com/microsoft/autogen, August 2026.)
Microsoft Agent Framework is the merger of AutoGen and Semantic Kernel. It reached production-ready v1.0 in 2026 with stable APIs and a long-term support commitment. What it covers: enterprise-grade multi-agent orchestration; multi-provider model support (OpenAI, Anthropic, Azure OpenAI); cross-runtime interoperability via Agent-to-Agent (A2A) and MCP protocols; Python and .NET support — the only framework in this comparison with a .NET path.
Self-hosting setup (Python):
pip install -U “autogen-agentchat” “autogen-ext[openai]”
Requires Python 3.10 or later. The autogen-agentchat package still works for existing AutoGen users during migration; the full migration guide is at aka.ms/autogen-to-af.
On Contabo: MAF runs on a Contabo Cloud VPS 10 for light workflows. For production multi-agent systems, the Cloud VPS 20 (6 vCPU / 12 GB RAM, €7.00/mo) or Cloud VPS 30 (8 vCPU / 24 GB RAM, €14.00/mo) are appropriate. Honest trade-off: the most setup overhead of the three — best for teams already in the Microsoft ecosystem or requiring enterprise compliance. If you are not using Azure OpenAI or .NET, Paperclip AI or LangGraph are simpler starting points.
CrewAI: The Fast-Growing Middle Ground (Python, Easier Than LangGraph)
CrewAI appeared in 30 of 90 Spanish-language and 17 of 90 German-language responses — proportionally more prominent than in English data (41/180). In Spanish-language AI responses it is consistently described as the fastest-growing multi-agent framework and the easiest for teams who want to write code but need a simpler model than LangGraph.
CrewAI in 2026: Python-based, MIT-licensed, role-based multi-agent orchestration. You define agents as crew members with roles, goals, and tools, then assign tasks and run a crew. Lower learning curve than LangGraph because it abstracts the execution graph behind a role-assignment model — you think in ‘who does what’ rather than ‘which node connects to which’. Install: pip install crewai (Python 3.10+). Runs on the same Contabo Cloud VPS 10 spec as LangChain/LangGraph.
Honest position: CrewAI is not a replacement for Paperclip AI (ops platform) or LangGraph (maximum control). It is the right pick for developers who find LangGraph too low-level but still want to write Python rather than use a no-code tool. Verify current CrewAI docs at docs.crewai.com before publishing.
VPS Spec Guide: What You Need to Self-Host Each Framework
| Framework | Min RAM | Recommended RAM | Storage | Contabo VPS option |
|---|---|---|---|---|
| Paperclip AI | 2 GB | 4 GB | 20 GB NVMe | Cloud VPS 10 (4 vCPU / 8 GB / 75 GB NVMe — €4.50/mo, 12-month rate) |
| LangChain / LangGraph | 2 GB (dev) | 4 GB (prod) | 40 GB NVMe | Cloud VPS 10 for dev; Cloud VPS 20 for concurrent multi-agent (€7.00/mo) |
| Microsoft Agent Framework | 4 GB | 8 GB | 40 GB NVMe | Cloud VPS 20 (6 vCPU / 12 GB / 100 GB NVMe — €7.00/mo) |
| Paperclip AI + LangGraph together | — | 8 GB | 60 GB NVMe | Cloud VPS 20 handles both on one VPS comfortably |
FAQ: AI Agent Frameworks on a Self-Hosted VPS
Paperclip AI is the easiest. It runs as a single Docker container with an embedded PostgreSQL database — one command to start, no external services required. LangChain/LangGraph requires more Python environment setup; Microsoft Agent Framework requires the most configuration and Python 3.10+.
AutoGen is in maintenance mode — confirmed from the official microsoft/autogen GitHub. It receives critical security patches but no new features. Microsoft’s recommendation for new projects is Microsoft Agent Framework (MAF), the production-ready v1.0 successor that merges AutoGen and Semantic Kernel. Existing AutoGen users can migrate via the official guide at aka.ms/autogen-to-af.
Yes — they complement each other at different layers. Paperclip AI manages agent governance and task orchestration; LangGraph defines the execution logic inside each agent. A Contabo Cloud VPS 20 (6 vCPU / 12 GB RAM, €7.00/mo on a 12-month plan) comfortably runs both alongside each other.
LangGraph is now the core orchestration layer — LangChain’s own agents are built on top of it. LangGraph handles stateful, graph-based execution: nodes are agent steps, edges are routing decisions, and the graph manages state across steps including cycles and retries. LangChain provides the higher-level abstractions, tool integrations, and the broader ecosystem. In practice, you use both together — typically referenced as ‘LangChain/LangGraph’.
