Migration Overview

Bring your existing AI agents to AgentBreeder in minutes. Your framework code stays the same. AgentBreeder wraps it with governance, multi-cloud deploy, and org-wide discoverability.

Why Migrate?

You already built an agent. It works. But now you need:

Challenge	Without AgentBreeder	With AgentBreeder
Deploy to production	Write Dockerfiles, Terraform, CI/CD pipelines	`agentbreeder deploy agent.yaml`
Multi-cloud	Rewrite infra per cloud provider	Change one line: `cloud: aws` or `cloud: gcp`
RBAC & access control	Build from scratch or skip it	Automatic -- every deploy checks permissions
Cost tracking	Manual token counting, spreadsheets	Per-agent, per-team, per-model cost attribution
Audit trail	Hope someone wrote it down	Every deploy, invocation, and config change logged
Agent discovery	Slack messages asking "who built that agent?"	Org-wide searchable registry
Guardrails	Roll your own PII detection, content filters	Declarative: `guardrails: [pii_detection]`
Model fallbacks	Try/catch with hardcoded alternatives	`model: { primary: claude-sonnet-4, fallback: gpt-4o }`
Scaling	Configure autoscaling per cloud	`scaling: { min: 1, max: 10, target_cpu: 70 }`

What AgentBreeder does NOT do: It does not replace your framework. Your LangGraph graphs, CrewAI crews, OpenAI agents, and custom code run exactly as-is inside the container AgentBreeder builds. Think of it as the deployment and governance layer that sits around your agent.

Quick Decision Matrix

You're using...	Migration time	Difficulty	Guide
LangGraph	~15 minutes	Easy	LangGraph guide
CrewAI	~20 minutes	Easy	CrewAI guide
OpenAI Agents SDK	~15 minutes	Easy	OpenAI Agents guide
Microsoft AutoGen	~30 minutes	Moderate	AutoGen guide
Custom Python agent	~20 minutes	Easy	Custom guide
No existing agent	~5 minutes	Trivial	Use `agentbreeder init` to scaffold

5-Minute Quick Start (Any Framework)

Regardless of your framework, the migration follows the same three steps:

Step 1: Keep your agent code

my-agent/
  agent.py          # <-- your existing code, unchanged
  requirements.txt  # <-- your existing deps

Step 2: Add agent.yaml

name: my-agent
version: 1.0.0
team: my-team
owner: me@company.com
framework: langgraph  # or crewai, openai_agents, custom

model:
  primary: gpt-4o

deploy:
  cloud: local

Step 3: Deploy

pipx install agentbreeder    # or: python3 -m pip install agentbreeder
agentbreeder deploy agent.yaml

That is the entire migration. Everything else -- RBAC, registry, cost tracking, health checks -- happens automatically.

Feature Comparison: What AgentBreeder Adds

Feature	LangGraph	CrewAI	OpenAI Agents	AutoGen	Custom	AgentBreeder
Agent logic / LLM calls	Native	Native	Native	Native	Native	Uses your framework
Containerization	Manual	Manual	Manual	Manual	Manual	Automatic
Multi-cloud deploy	Manual	Manual	Manual	Manual	Manual	`cloud: aws\|gcp\|local`
Autoscaling	Manual	Manual	Manual	Manual	Manual	Declarative YAML
RBAC	--	--	--	--	--	Automatic
Cost tracking	--	LangSmith	--	--	--	Automatic
Audit trail	--	--	--	--	--	Automatic
Agent registry	--	--	--	--	--	Automatic
Model fallbacks	Manual	Manual	Manual	Manual	Manual	Declarative YAML
Guardrails	Manual	Manual	Manual	Manual	Manual	Declarative YAML
Health checks	Manual	Manual	Manual	Manual	Manual	Automatic
MCP server support	Manual	--	--	--	Manual	Sidecar injection
Multi-agent orchestration	LangGraph-native	CrewAI-native	Handoffs	GroupChat	Manual	`orchestration.yaml` (framework-agnostic)
A2A protocol	--	--	--	--	--	Built-in
Visual builder (No Code)	--	--	--	--	--	Studio
CLI workflow	--	--	--	--	--	`agentbreeder deploy/status/logs/teardown`

What Stays the Same After Migration

This is important: AgentBreeder does not modify your agent code. Your framework-specific logic runs inside a container that AG builds and manages. Specifically:

Your agent.py / main.py files are unchanged
Your requirements.txt / pyproject.toml are preserved (AG adds framework deps if missing)
Your LLM API calls go through the same providers
Your tools, prompts, and logic are identical
You can still run your agent locally without AgentBreeder (just python agent.py)

What AG adds is a server wrapper (server.py) that exposes your agent as an HTTP service with /invoke and /health endpoints, plus the deploy infrastructure.

Architecture: How It Works

                    Your Code              AgentBreeder Adds
                 +--------------+     +------------------------+
                 |  agent.py    |     |  server.py (wrapper)   |
                 |  tools.py    |     |  Dockerfile (generated)|
  agent.yaml -> |  prompts/    | --> |  Health checks         |
                 |  requirements|     |  OpenTelemetry sidecar |
                 +--------------+     +------------------------+
                                              |
                                    +---------+---------+
                                    |                   |
                              agentbreeder deploy        agentbreeder deploy
                              --target local       --target aws
                                    |                   |
                              Docker Compose       ECS Fargate
                                    |                   |
                              localhost:8080     https://my-agent.ecs.aws
                                    |                   |
                              +-----+-------------------+-----+
                              |         Registry              |
                              |   RBAC | Audit | Cost Track   |
                              +-------------------------------+

Common Questions

Q: Do I need to rewrite my agent? No. Your agent code is unchanged. You add an agent.yaml file and run agentbreeder deploy.

Q: Can I still run my agent without AgentBreeder? Yes. Your agent.py still works standalone. AgentBreeder is additive.

Q: What if my framework isn't listed? Use framework: custom. See the Custom migration guide. Any Python agent that can be called via a function works.

Q: Does AgentBreeder lock me in? No. Your agent code has zero AgentBreeder imports. The agent.yaml is a declarative config file. You can stop using AG at any time and deploy your container manually.

Q: What about multi-agent systems? AgentBreeder has orchestration.yaml for defining multi-agent workflows (sequential, parallel, router, supervisor, fan-out/fan-in). Your framework's native orchestration (LangGraph subgraphs, CrewAI processes, OpenAI handoffs) also works as-is inside the container.

Next Steps

Pick your migration guide:

On this page