Why Automagent

Your agents deserve better than
framework lock-in.

Agent definitions are scattered, unvalidated, and locked to frameworks. Automagent gives you one open spec that works everywhere.

Get Started See Features
Beyond Git

Git is not enough.

Version control stores files. It has no idea what an agent is. Here is what you gain when your agent definitions speak a real spec.

Validation

Git alone

Stores any YAML blindly. Typos, leaked API keys, and invalid model names ship to production.

Git + Automagent

automagent validate checks your definition against the schema, catches secrets, verifies model configs, and confirms file references exist.

Type Safety

Git alone

A git repo does not know what an agent is. A missing field is just a missing field.

Git + Automagent

agent.yaml has a JSON Schema. Editors autocomplete fields, CI enforces structure, misconfigurations fail fast before deploy.

Framework Translation

Git alone

Switching from CrewAI to LangChain means rewriting everything by hand.

Git + Automagent

automagent import converts CrewAI, OpenAI Agents SDK, and LangChain definitions into a universal format. One file, any framework.

Local Testing

Git alone

Git does not run your code. Testing means wiring up a framework, writing boilerplate, and hoping the config is right.

Git + Automagent

automagent run starts an interactive chat session with your agent definition. Test locally, iterate fast, no framework required.

Multi-Agent Composition

Git alone

Git has no concept of agent teams. Orchestrating multiple agents means custom glue code for every project.

Git + Automagent

agent-compose.yaml defines roles, handoffs, and shared context for multi-agent teams. Declare the workflow, not the wiring.

Governance

Git alone

Git does not enforce behavioral rules. Guardrails live in tribal knowledge and code review comments.

Git + Automagent

The spec includes guardrails, compliance tagging, PII policies, and approval workflows. Governance is declarative, not aspirational.

Ready to try it?

Get Started in 60 Seconds

Stop shipping broken agent configs

Every agent.yaml is validated against JSON Schema v7 using Ajv at runtime. No more shipping broken configs to production and finding out from a stack trace. The CLI runs a 4-step pipeline: schema structure, model identifier checks, secret detection, and context file verification. Errors are specific and actionable.

@automagent/schema
Terminal
$ automagent validate Validating agent.yaml... ✓ Schema valid (v1) ⚠ Model "gpt-4" is unpinned — consider using a versioned identifier ✓ No secrets detected ✓ Context files verified 1 warning, 0 errors

Switch frameworks without rewriting

Already have agents defined in CrewAI, OpenAI Agents SDK, or LangChain? Import them. automagent import auto-detects the source format and converts it to a standard agent.yaml. No manual rewriting required. Your agent definitions are portable from day one — no vendor lock-in, no migration dread.

automagent import
Before → After
crewai.yaml
agents: reviewer: role: Code Reviewer goal: Review PRs backstory: Senior eng llm: gpt-4o
agent.yaml
name: reviewer description: Review PRs model: id: gpt-4o-2024-08-06 provider: openai instructions: Senior eng

Give your agent tools without custom wiring

Agents need tools, and MCP (Model Context Protocol) is how they get them. Automagent has first-class support for MCP — declare servers by name, transport type, and connection details directly in your agent definition. Both stdio and streamable-http transports are supported. Your agent discovers capabilities at runtime without any custom wiring.

stdio + streamable-http
agent.yaml
mcp: - name: github transport: stdio command: npx @modelcontextprotocol/server-github - name: slack transport: streamable-http url: https://mcp.slack.com/sse

Build agent teams that hand off work

Real workflows need more than one agent. agent-compose.yaml lets you define teams of specialized agents with declared roles, dependency ordering, and shared context. Each agent handles what it's good at; the compose file handles how they hand off work. Think docker-compose, but for agent orchestration.

agent-compose.yaml
agent-compose.yaml
# agent-compose.yaml name: content-team agents: - name: researcher role: Find and verify facts - name: writer role: Draft content from research depends_on: [researcher] - name: editor role: Polish and fact-check drafts depends_on: [writer]

Swap models without touching code

Declare your primary model, a fallback for when it's unavailable, and a list of compatible alternatives for cost optimization or latency tuning. Switch providers without touching your agent logic. Pin exact model versions to avoid surprise regressions. Temperature, max tokens, and other settings live alongside the model declaration.

model.fallback + model.compatible
agent.yaml
model: id: claude-sonnet-4-20250514 provider: anthropic fallback: gpt-4o-2024-08-06 compatible: - claude-haiku-4-5-20251001 - gpt-4o-mini settings: temperature: 0.3 max_tokens: 4096

Enforce policy at the definition layer

Behavioral rules, prohibited actions, and compliance requirements are first-class fields in the spec — not afterthoughts bolted on later. Define what your agent must never do, tag data classification levels, and declare compliance frameworks like SOC2, GDPR, or HIPAA. PII handling policies are explicit: redact, mask, or block. Governance is declarative, auditable, and version-controlled.

guardrails + governance
agent.yaml
guardrails: behavioral: - Never share internal pricing data - Always cite sources for factual claims prohibited_actions: - Executing arbitrary code - Accessing external URLs not in allowlist governance: data_classification: confidential compliance_frameworks: [SOC2, GDPR] pii_handling: redact
From Solo to Enterprise

One spec. Every scale.

The agent.yaml you write on your laptop is the same file that governs thousands in production. No rewrites, no migration, no vendor lock-in.

Solo Developer

Start with a single agent.yaml. Validate, run, and iterate locally.

  • Version control your agent definitions as files, not UI state
  • Validate schemas and catch secrets before they ship
  • Hot-swap models by changing one line
  • Import from CrewAI, LangChain, or raw prompts in one command

Team

Share agents across your team with private hubs and composable workflows.

  • Private team hub with access controls and version history
  • Compose multi-agent teams with declared roles and handoffs
  • Shared tool and MCP server configurations across agents
  • Framework translation bridges CrewAI and LangChain users

Enterprise

Centralized governance for your entire AI fleet.

  • Mandatory guardrails and behavioral rules across all agents
  • SOC2, GDPR, HIPAA compliance tagging with automatic enforcement
  • PII handling policies, data residency, and full audit trails
  • Department-scoped distribution with granular permissions

Ready to build?

Install the CLI. Define your first agent. Ship with confidence.

$ npm install -g automagent
Read the Docs Browse the Hub →