agent.yaml Reference

The agent.yaml file is the canonical configuration for an AgentBreeder agent. It defines everything needed to build, deploy, and govern an agent.

TL;DR

Six fields are required: name, version, team, owner, framework, model.primary, deploy.cloud. Everything else is optional.

name: my-agent
version: 1.0.0
team: engineering
owner: dev@company.com
framework: langgraph              # langgraph | openai_agents | claude_sdk | crewai | google_adk | custom
model:
  primary: claude-sonnet-4
deploy:
  cloud: local                    # local | aws | gcp | azure | kubernetes | claude-managed

Common additions: model.fallback, tools:, prompts:, guardrails:, deploy.scaling, deploy.secrets:, access:. Framework-specific blocks (claude_sdk, google_adk, claude_managed) are only read by their matching runtime.

Jump to: Top-level fields · model · tools · deploy · access · Framework-specific.

Minimal Example

name: my-agent
version: 1.0.0
team: engineering
owner: dev@company.com
framework: langgraph

model:
  primary: claude-sonnet-4

deploy:
  cloud: local

Complete Example

spec_version: v1

name: customer-support-agent
version: 1.0.0
description: "Handles tier-1 customer support tickets"
team: customer-success
owner: alice@company.com
tags: [support, zendesk, production]

framework: langgraph

model:
  primary: claude-sonnet-4
  fallback: gpt-4o
  gateway: litellm
  temperature: 0.7
  max_tokens: 4096

tools:
  - ref: tools/zendesk-mcp
  - ref: tools/order-lookup
  - name: search
    type: function
    description: "Search knowledge base"
    schema: {}

knowledge_bases:
  - ref: kb/product-docs
  - ref: kb/return-policy

prompts:
  system: prompts/support-system-v3

guardrails:
  - pii_detection
  - hallucination_check
  - content_filter
  - name: custom_check
    endpoint: https://guardrails.company.com/check

subagents:
  - ref: agents/billing-agent
    name: billing
    description: "Handles billing queries"

mcp_servers:
  - ref: mcp/zendesk
    transport: sse

deploy:
  cloud: gcp             # local | gcp | aws | azure | kubernetes | claude-managed
  runtime: cloud-run
  region: us-central1
  scaling:
    min: 1
    max: 10
    target_cpu: 70
  resources:
    cpu: "1"
    memory: "2Gi"
  env_vars:
    LOG_LEVEL: info
    ENVIRONMENT: production
  secrets:
    - ZENDESK_API_KEY
    - OPENAI_API_KEY

access:
  visibility: team
  allowed_callers:
    - team:engineering
    - team:customer-success
  require_approval: false

Field Reference

Top-Level Fields

Field	Type	Required	Description
`spec_version`	string	No	Schema version. Currently `v1`.
`name`	string	Yes	Agent name. Slug-friendly: lowercase alphanumeric and hyphens, 2–63 characters. Must start and end with alphanumeric.
`version`	string	Yes	Semantic version (`X.Y.Z`).
`description`	string	No	Short description, max 500 characters.
`team`	string	Yes	Owning team name.
`owner`	string	Yes	Email of the responsible engineer.
`tags`	string[]	No	Tags for discovery and search.
`framework`	string	Yes	Agent framework. See Framework values.

`framework`

For Python agents, set framework directly (top-level field). For TypeScript or Go agents, use the runtime: block instead — see below. (Kotlin / Rust / .NET are roadmap — see Polyglot Agents.)

Value	Framework	Runtime
`langgraph`	LangGraph	✅ Available
`openai_agents`	OpenAI Agents SDK	✅ Available
`crewai`	CrewAI	✅ Available
`claude_sdk`	Anthropic Claude SDK	✅ Available
`google_adk`	Google Agent Development Kit	✅ Available
`custom`	Any Python agent	✅ Available

`language:` field

Top-level optional. Declares the agent's implementation language. Defaults to python for back-compat with v1 configs that omit it. Closed enum:

language: python    # python | typescript | node | go | kotlin | java | rust | csharp | custom
framework: langgraph

The language: field drives base-image and SDK selection. For Python agents you can omit it entirely. For everything else, set it (and use the runtime: block below for non-Python frameworks). See Polyglot Agents and the Runtime Contract for the full picture.

`runtime:` block — Polyglot Agents (TypeScript, Go)

For non-Python agents, replace the top-level framework field with a runtime: block. framework and runtime: are mutually exclusive.

runtime:
  language: node        # python | node | rust | go
  framework: vercel-ai  # open string — validated against the plugin registry
  version: "20"         # optional: language runtime version (e.g. Node.js major)
  entrypoint: agent.ts  # optional: overrides the default entry file per language

Field	Required	Description
`language`	Yes	Language runtime: `python`, `node`, `rust`, `go`
`framework`	No	Framework name. Defaults to `custom` if omitted.
`version`	No	Language version (e.g. `"20"` for Node 20, `"1.78"` for Rust).
`entrypoint`	No	Entry file. Defaults: `agent.ts` (node), `main.rs` (rust), `main.go` (go), `agent.py` (python).

Supported language + framework combinations:

Language	Available frameworks	Status
`python`	Use top-level `framework` field — do not use `runtime:`	shipped
`node`	`vercel-ai`, `mastra`, `langchain-js`, `openai-agents-ts`, `custom`	shipped
`go`	`custom` (with the Go SDK)	shipped in v2.0
`kotlin` / `rust` / `csharp`	reserved enum values	roadmap — #188, #189, #190

See Polyglot Agents for full setup, sidecar wiring, and cross-language A2A calls.

Framework-Specific Configuration

Each framework supports optional configuration under a top-level key matching the framework name. These keys are only read by the corresponding runtime.

`claude_sdk` — Anthropic Claude SDK

claude_sdk:
  thinking:
    enabled: true           # false (default) — enable adaptive thinking
    effort: high            # "low" | "medium" | "high" (default: "high")
  prompt_caching: true      # Enable prompt caching for long system prompts (default: false)
  routing:
    provider: anthropic     # "anthropic" (default) | "vertex_ai" | "bedrock"
    project_id: ""          # Required for vertex_ai
    region: ""              # Required for vertex_ai and bedrock

Field	Type	Default	Description
`thinking.enabled`	boolean	`false`	Enable adaptive thinking. When `true`, the agent uses extended thinking for complex queries.
`thinking.effort`	string	`"high"`	Thinking compute budget. One of `"low"`, `"medium"`, `"high"`. Maps to `output_config.effort` in the API.
`prompt_caching`	boolean	`false`	Cache the system prompt via Anthropic's prompt caching API. Reduces latency and cost when the system prompt is reused across many requests. Minimum length thresholds: 8 192 chars for Sonnet models, 16 384 chars for others.
`routing.provider`	string	`"anthropic"`	Provider endpoint: `"anthropic"` (direct), `"vertex_ai"` (GCP), or `"bedrock"` (AWS).
`routing.project_id`	string	—	GCP project ID. Required when `routing.provider` is `"vertex_ai"`.
`routing.region`	string	—	Cloud region. Required when `routing.provider` is `"vertex_ai"` or `"bedrock"`.

Environment variables injected by the runtime:

Variable	Description
`AGENT_MODEL`	Claude model ID (e.g., `claude-sonnet-4-6`)
`AGENT_MAX_TOKENS`	Max tokens for responses (default: `4096`)
`AGENT_SYSTEM_PROMPT`	System prompt injected at startup
`AGENT_TOOLS_JSON`	JSON array of tool definitions
`AGENT_THINKING_CONFIG`	JSON object with thinking configuration
`AGENT_PROMPT_CACHING`	`"true"` when prompt caching is enabled

`crewai` — CrewAI

crewai:
  process: sequential       # "sequential" (default) | "hierarchical" | "parallel"
  manager_llm: gpt-4o       # Required when process=hierarchical
  verbose: false            # Enable verbose CrewAI output (default: false)
  memory: false             # Enable crew-level memory (default: false)
  memory_config: {}         # Advanced memory provider config passed to Crew(memory_config=...)

Field	Type	Default	Description
`process`	string	`"sequential"`	Crew execution process. `"hierarchical"` requires `manager_llm`.
`manager_llm`	string	—	Model ref for the manager agent. Required when `process: hierarchical`.
`verbose`	boolean	`false`	Enable verbose output from CrewAI.
`memory`	boolean	`false`	Enable crew-level memory for long-term knowledge.
`memory_config`	object	—	Advanced memory provider config passed directly to `Crew(memory_config=...)`.

The CrewAI runtime automatically injects AGENT_MODEL and AGENT_TEMPERATURE from the top-level model: block into every agent in the crew. Your crew.py does not need to read these environment variables — the runtime sets them on each agent.llm object at startup.

Environment variables injected by the runtime:

Variable	Description
`AGENT_MODEL`	LLM model name (propagated to each crew agent's LLM)
`AGENT_TEMPERATURE`	Sampling temperature (propagated to each crew agent's LLM)
`AGENT_TOOLS_JSON`	JSON array of tool definitions from the registry

The crew module must export either a crew attribute (a Crew instance) or a flow attribute (a Flow instance). Both sync and async (akickoff) crew execution are supported.

`google_adk` — Google Agent Development Kit

google_adk:
  session_backend: memory       # "memory" (default) | "database" | "vertex_ai"
  session_db_url: ""            # Required when session_backend is "database"
  memory_service: memory        # "memory" (default) | "vertex_ai_bank" | "vertex_ai_rag"
  artifact_service: memory      # "memory" (default) | "gcs"
  gcs_bucket: ""                # Required when artifact_service is "gcs"
  streaming: none               # "none" (default) | "sse" | "bidi"

Field	Type	Default	Description
`session_backend`	string	`"memory"`	Session storage backend. `"database"` requires `DATABASE_URL`. `"vertex_ai"` uses Vertex AI session service and requires `GOOGLE_CLOUD_PROJECT`.
`session_db_url`	string	—	PostgreSQL URL for database session storage. Falls back to `DATABASE_URL` env var.
`memory_service`	string	`"memory"`	Memory persistence service. `"vertex_ai_bank"` and `"vertex_ai_rag"` require `GOOGLE_CLOUD_PROJECT`.
`artifact_service`	string	`"memory"`	Artifact storage service. `"gcs"` requires a GCS bucket name.
`gcs_bucket`	string	—	GCS bucket name for artifact storage. Falls back to `GCS_ARTIFACT_BUCKET` env var.
`streaming`	string	`"none"`	Streaming mode for `RunConfig`. `"sse"` = Server-Sent Events, `"bidi"` = bidirectional streaming.

Environment variables injected by the runtime:

Variable	Description
`AGENT_MODEL`	Gemini model ID (applied to `agent.model` at startup)
`AGENT_TEMPERATURE`	Sampling temperature (applied via `generate_content_config`)
`AGENT_MAX_TOKENS`	Max output tokens (applied via `generate_content_config`)
`AGENTBREEDER_ADK_CONFIG`	JSON blob of the `google_adk:` config block
`GOOGLE_CLOUD_PROJECT`	GCP project for Vertex AI services
`GOOGLE_CLOUD_LOCATION`	GCP region (default: `us-central1`)

The agent module must export one of: root_agent, agent, or app (a google.adk.agents.Agent instance). Alternatively, a root_agent.yaml file (ADK config-based agents) is supported as a fallback.

Streaming — `/stream` SSE Endpoint

All deployed agents expose a /stream endpoint alongside /invoke. The endpoint streams execution progress as Server-Sent Events.

Request: same body as /invoke

Response: text/event-stream

Framework	SSE events
Claude SDK	`data: {"text": "..."}` — one event per streamed text chunk
CrewAI	`event: step` with `{"description": "...", "result": "..."}` for each crew step; `event: result` with the final output
Google ADK	`data: {"text": "...", "is_final": false\|true}` — one event per ADK event

All streams terminate with data: [DONE].

Example (curl):

curl -N -X POST https://<agent-endpoint>/stream \
  -H "Content-Type: application/json" \
  -d '{"input": "Summarize this quarter'\''s results"}'

`model`

Model configuration for the agent's LLM.

Field	Type	Required	Description
`primary`	string	Yes	Primary model. Registry reference or `provider/model-id`.
`fallback`	string	No	Fallback model if primary is unavailable.
`gateway`	string	No	Model gateway (e.g., `litellm`). Defaults to org setting.
`temperature`	number	No	Sampling temperature, 0–2.
`max_tokens`	integer	No	Maximum tokens per response.

Gateway values:

Gateway	Description
`litellm`	Route through LiteLLM proxy
`ollama`	Route to local Ollama instance
(unset)	Direct provider call via the provider abstraction layer

The provider abstraction layer (engine/providers/) supports OpenAI and Ollama natively, with automatic fallback chains when fallback is specified.

Examples:

model:
  primary: claude-sonnet-4

model:
  primary: claude-sonnet-4
  fallback: gpt-4o
  gateway: litellm
  temperature: 0.7
  max_tokens: 4096

# Local development with Ollama
model:
  primary: ollama/llama3
  gateway: ollama

`gateways` (v2.0+, optional)

Workspace-level gateway overrides. Most agents do not need this block — the catalog defaults are correct. Use it when you need to point LiteLLM at a different proxy URL, or set a per-agent OpenRouter key:

gateways:
  litellm:
    url: https://litellm.platform.example.com    # overrides catalog default
    api_key_env: PLATFORM_LITELLM_KEY
    fallback_policy: fastest                      # advisory; not enforced yet
  openrouter:
    api_key_env: TEAM_OPENROUTER_KEY
    default_headers:                              # merged with catalog defaults
      X-Tenant: my-team

Each top-level key is a gateway preset name from engine/providers/catalog.yaml (or your ~/.agentbreeder/providers.local.yaml). Every nested field is optional and falls back to the catalog default. See Gateways for the full picture and engine.providers.catalog.parse_gateway_ref for the routing implementation.

Note: the long-term home for gateways: is workspace.yaml; per-agent overrides remain valid once Track A (#146) ships.

`tools`

List of tools and MCP servers available to the agent.

Each tool is either a registry reference or an inline definition:

tools:
  # Registry reference (recommended)
  - ref: tools/zendesk-mcp

  # Inline definition
  - name: search
    type: function
    description: "Search knowledge base"
    schema: {}

  # With Human-in-the-Loop approval
  - ref: tools/send-email
    approval:
      require: true
      timeout: 30m
      notify:
        - slack: "#approvals"
        - email: admin@company.com

Field	Type	Required	Description
`ref`	string	No	Registry reference path.
`name`	string	No	Tool name (for inline definitions).
`type`	string	No	Tool type: `function`, `computer_use_20260401` (browser/computer use), or `agent_toolset_20260401` (full built-in toolset).
`description`	string	No	Tool description.
`schema`	object	No	OpenAPI-compatible schema.
`approval.require`	boolean	No	If `true`, every call to this tool must be approved by a human before execution.
`approval.timeout`	string	No	How long to wait for human approval (e.g., `30m`, `1h`).
`approval.notify`	array	No	Notification channels. Each item is `{slack: "#channel"}` or `{email: "addr"}`.

`subagents`

List of subagent references for A2A (agent-to-agent) communication. Each reference auto-generates a call_{name} tool during dependency resolution.

subagents:
  - ref: agents/billing-agent
    name: billing
    description: "Handles billing queries"
  - ref: agents/tech-support

Field	Type	Required	Description
`ref`	string	Yes	Registry reference path to the subagent.
`name`	string	No	Display name (defaults to slug from ref).
`description`	string	No	Description of the subagent's purpose.

`mcp_servers`

List of MCP server references the agent can call. At deploy time each entry is either forwarded to a remote URL or co-deployed as a sidecar container, and the AgentBreeder sidecar exposes it to the agent at http://localhost:9091/mcp/<name>.

mcp_servers:
  - ref: mcp/zendesk          # registry reference
    transport: sse
    url: https://mcp.acme.com/sse   # remote server — sidecar forwards here
  - ref: mcp/slack
    transport: sse
    image: acme/mcp-slack:1.2.3     # co-deployed as a sidecar container
    port: 3100                       # localhost port (auto from 3100 if omitted)

Field	Type	Required	Default	Description
`ref`	string	Yes	—	Registry reference path to the MCP server.
`transport`	string	No	`stdio`	MCP transport type: `stdio`, `sse`, `streamable_http`.
`url`	string	No	—	Remote HTTP/SSE MCP server URL. When set, the sidecar forwards directly to it (no container is co-deployed).
`image`	string	No	—	Container image to co-deploy as an MCP sidecar (reachable over localhost).
`port`	integer	No	`3100+`	Localhost port for a co-deployed MCP container. Auto-assigned from 3100 when omitted.

When neither url nor image is given, the deployer co-deploys a conventionally-named image (agentbreeder/mcp-<name>:latest). Co-deploy works on multi-container targets (AWS ECS, GCP Cloud Run, Azure Container Apps, docker-compose); single-container targets (App Runner) can only use remote url servers. A remote stdio server cannot be forwarded — use sse/http, or co-deploy an image.

`knowledge_bases`

List of knowledge base references.

knowledge_bases:
  - ref: kb/product-docs
  - ref: kb/return-policy
    backend_url: postgresql://pgvector-host:5432/rag_db   # optional explicit DSN

Field	Type	Required	Description
`ref`	string	Yes	Registry reference path.
`backend_url`	string	No	Explicit cloud-reachable vector-store DSN (pgvector) or graph URL for this knowledge base. Overrides the registry-resolved default at deploy time.

`memory`

Memory store references. Each entry must match a memory.yaml store entry (e.g. a Redis buffer window or PostgreSQL entity store).

memory:
  stores:
    - mem/session-buffer
    - mem/entity-store
  backend: redis             # "redis" | "postgresql" — omit to resolve from registry
  backend_url: redis://memory-host:6379   # optional explicit connection string

Cloud backends. A deployed agent never inherits your laptop's REDIS_URL/DATABASE_URL. Either set backend_url explicitly, or let agentbreeder deploy provision a managed backend. For local Docker Compose, set AGENTBREEDER_ALLOW_LOCAL_BACKENDS=1 to reuse the compose services.

Field	Type	Required	Description
`stores`	string[]	No	List of memory store refs (e.g. `mem/session-buffer`, `mem/entity-store`).
`backend`	string	No	Memory backend type: `"redis"` or `"postgresql"`. Omit to resolve from the registry.
`backend_url`	string	No	Explicit cloud-reachable connection string for the memory backend. Overrides the registry-resolved default at deploy time.

`prompts`

Prompt configuration.

# Registry reference
prompts:
  system: prompts/support-system-v3

# Inline
prompts:
  system: "You are a helpful customer support agent..."

Field	Type	Required	Description
`system`	string	No	System prompt — registry reference or inline string.

`guardrails`

List of guardrails to enforce on agent outputs. Can be built-in names or custom endpoints.

guardrails:
  - pii_detection           # Built-in
  - hallucination_check     # Built-in
  - content_filter          # Built-in
  - hitl_approve            # Built-in — route every output through human approval queue
  - name: custom_check      # Custom
    endpoint: https://guardrails.company.com/check
    action: warn            # "block" (default) | "warn" | "hitl_approve"

Built-in guardrails:

Name	Description
`pii_detection`	Strips PII from outputs
`hallucination_check`	Flags low-confidence responses
`content_filter`	Blocks harmful content
`hitl_approve`	Routes every agent output through the human-in-the-loop approval queue

Custom guardrail fields:

Field	Type	Required	Description
`name`	string	Yes	Guardrail name.
`endpoint`	string	No	URL of the guardrail service.
`action`	string	No	Action on trigger: `"block"` (default), `"warn"` (log but pass through), or `"hitl_approve"` (route to approval queue).

`deploy`

Deployment configuration.

Status: Deploy-target availability (which targets ship full governance, greenfield provisioning, and secret auto-mirror) is maintained in one canonical place — see the deploy-target status table.

Field	Type	Required	Default	Description
`cloud`	string	Yes	—	Target platform: `local`, `aws`, `gcp`, `azure`, `kubernetes`, `claude-managed`.
`runtime`	string	No	Per cloud	Deployment runtime. See defaults below.
`region`	string	No	—	Cloud region (e.g., `us-east-1`). Not used for `claude-managed`.
`scaling`	object	No	See below	Auto-scaling configuration. Not used for `claude-managed`.
`resources`	object	No	See below	CPU and memory allocation. Not used for `claude-managed`.
`env_vars`	map	No	—	Non-secret environment variables.
`secrets`	string[]	No	—	Secret names. Resolved at deploy time from your workspace secrets backend and auto-mirrored to the target cloud's native store under `agentbreeder/{agent}/{secret}`. The container env wires to the cloud-native secret reference — plaintext never lands on disk.

Supported runtimes by cloud:

Cloud	Default Runtime	Other Runtimes	Notes
`local`	`docker-compose`	—	Requires Docker
`aws`	`ecs-fargate`	`app-runner`	App Runner = no VPC/ALB required
`gcp`	`cloud-run`	—	Scales to zero by default
`azure`	`container-apps`	—
`kubernetes`	`deployment`	`eks`, `gke`, `aks`	Bring your own cluster
`claude-managed`	(n/a)	—	No container built; Anthropic manages the runtime

`deploy.scaling`

Field	Type	Default	Description
`min`	integer	`1`	Minimum instances (0 = scale to zero).
`max`	integer	`10`	Maximum instances.
`target_cpu`	integer	`70`	CPU % threshold to trigger scaling (1–100).

`deploy.resources`

Field	Type	Default	Description
`cpu`	string	`"0.5"`	vCPU units.
`memory`	string	`"1Gi"`	Memory allocation.

`deploy.identity`

Auto-creates a dedicated IAM Role (AWS) or Service Account (GCP) scoped to this agent at deploy time.

deploy:
  cloud: aws
  identity:
    create: true
    permissions:
      - "s3:GetObject:arn:aws:s3:::my-bucket/*"   # AWS IAM action:resource
    boundary: "arn:aws:iam::123456789:policy/AgentBoundary"

deploy:
  cloud: gcp
  identity:
    create: true
    roles:
      - "roles/storage.objectViewer"   # GCP IAM role

Field	Type	Default	Description
`create`	boolean	`false`	Auto-create a dedicated IAM role/service account for this agent.
`permissions`	string[]	—	AWS IAM permission strings in `action:resource` format.
`roles`	string[]	—	GCP IAM roles to grant the Service Account.
`boundary`	string	—	AWS IAM permissions boundary ARN — limits the maximum effective permissions.

`deploy.sidecar`

Configure the observability sidecar injected alongside every agent container. The sidecar provides OTel traces, cost attribution, and guardrail enforcement.

deploy:
  sidecar:
    enabled: true
    guardrails:
      - pii_detection
      - content_filter
    otel_endpoint: "http://otel-collector:4317"
    cost_tracking: true

Field	Type	Default	Description
`enabled`	boolean	`true`	Inject the AgentBreeder observability sidecar alongside the agent container.
`guardrails`	string[]	—	Guardrails to enforce in the sidecar (runs independently of the agent process).
`otel_endpoint`	string	—	Override the OpenTelemetry collector endpoint. Defaults to `OPENTELEMETRY_ENDPOINT` env var.
`cost_tracking`	boolean	`true`	Enable token-level cost attribution in the sidecar.

`access`

Access control configuration. Optional — defaults to team's policy.

Field	Type	Default	Description
`visibility`	string	`team`	One of: `public`, `team`, `private`.
`allowed_callers`	string[]	—	Restrict who can call this agent (e.g., `team:engineering`).
`require_approval`	boolean	`false`	If true, deploys require admin approval.

`claude_managed`

Optional block read only when deploy.cloud: claude-managed. No container is built — Anthropic manages the runtime.

claude_managed:
  environment:
    networking: unrestricted    # unrestricted | restricted
  tools:
    - type: agent_toolset_20260401   # full built-in toolset (default)

Field	Type	Default	Description
`environment.networking`	string	`unrestricted`	Network access for the managed environment.
`tools`	object[]	See default	Tool definitions passed to the Anthropic Agent API.

Mapping from agent.yaml to the Anthropic Agent API:

`agent.yaml` field	Anthropic API field
`model.primary`	`model`
`prompts.system`	`system`
`claude_managed.tools`	`tools`
`name`	`name`

CLI Deploy Targets

The --target flag on agentbreeder deploy maps to cloud + runtime combinations:

agentbreeder deploy --target local           # Docker Compose (local)
agentbreeder deploy --target cloud-run       # GCP Cloud Run
agentbreeder deploy --target ecs-fargate     # AWS ECS Fargate
agentbreeder deploy --target app-runner      # AWS App Runner (no VPC/ALB)
agentbreeder deploy --target container-apps  # Azure Container Apps
agentbreeder deploy --target kubernetes      # Kubernetes (EKS/GKE/AKS/self-hosted)
agentbreeder deploy --target claude-managed  # Anthropic Claude Managed Agents

All Frameworks × All Deployment Targets

This matrix is the canonical home for the framework/target compatibility grid — No Code, Low Code, and Full Code all compile to the same agent.yaml, so it applies to every builder tier equally.

	Local	App Runner	ECS Fargate	Cloud Run	Container Apps	Kubernetes	Claude Managed
LangGraph	✓	✓	✓	✓	✓	✓	✓
OpenAI Agents	✓	✓	✓	✓	✓	✓	✓
Claude SDK	✓	✓	✓	✓	✓	✓	✓
CrewAI	✓	✓	✓	✓	✓	✓	✓
Google ADK	✓	✓	✓	✓	✓	✓	✓
Custom	✓	✓	✓	✓	✓	✓	✓

Every framework compiles to every target. Governance availability per target is a separate axis — AWS App Runner is single-container (no sidecar, no guardrails:/secrets:) and Kubernetes + Claude-managed are in flight; see the deploy-target status table.

Claude Managed note

When deploying to claude-managed, no container is built — Anthropic manages the runtime. The framework field is still required and controls how the agent logic is structured inside the managed environment.

Validation

Validate your config without deploying:

agentbreeder validate ./agent.yaml

The JSON Schema is at engine/schema/agent.schema.json.

Name Constraints

Lowercase alphanumeric and hyphens only
Must start and end with an alphanumeric character
Length: 2–63 characters
Pattern: ^[a-z0-9][a-z0-9-]*[a-z0-9]$

Valid: my-agent, customer-support-v2, data-monitor Invalid: -my-agent, My_Agent, a

On this page