📖 Looking for the full docs, feature showcase, and use cases? Visit the Cortex landing page →

Cortex Agent Framework One YAML file. One method call. A production AI agent. Stop rebuilding the same agent plumbing. Define it once, deploy anywhere, let it learn.

Overview • Architecture • Features • Getting Started • Use Cases • Config • CLI • Deployment • FAQ

The problem

Every AI team builds the same stack: task decomposition, parallel tool execution, streaming, retries, session management, quality scoring, multi-provider routing, deployment. Most teams rebuild it two or three times before shipping.

Cortex is that stack. Pre-built. Battle-tested. Driven by config, not code.

3 commands. A running agent.

pip install cortex-agent-framework
cortex setup            # visual wizard at localhost:7799
cortex publish ui       # chat UI at localhost:8090

Or invoke the agent directly from the terminal:

cortex run "Research the latest vector DB benchmarks"
cortex chat                                            # interactive REPL

You now have a working agent with a professional web interface, file upload support, streaming responses, and persistent chat history. No frontend to build. No backend to wire. No infrastructure to manage.

Define your agent in YAML. Run it in Python.

agent:
  name: ResearchAgent
  description: Searches the web and writes reports

llm_access:
  default:
    provider: anthropic
    model: claude-sonnet-4-5
    api_key_env_var: ANTHROPIC_API_KEY

task_types:
  - name: web_research
    capability_hint: web_search
    output_format: md
  - name: write_report
    capability_hint: document_generation
    depends_on: [web_research]

from cortex.framework import CortexFramework

framework = CortexFramework("cortex.yaml")
await framework.initialize()

result = await framework.run_session(
    user_id="user_1",
    request="Research the latest vector DB benchmarks and write a report",
)
print(result.response)

Fan-out, tool calls, dependency resolution, synthesis, validation — all handled.

Or define it in Python — code-first agents

Prefer code to config? Build the entire agent with CortexBuilder and wire in code nodes — plain Python functions as graph nodes, LangGraph-style. No YAML file, no decomposition LLM call: the graph runs exactly as you wrote it.

from cortex import CortexBuilder, CortexFramework

agent = CortexBuilder("ResearchAgent", "Searches the web and writes reports")
agent.llm("anthropic", model="claude-sonnet-4-5", api_key_env="ANTHROPIC_API_KEY")
agent.tool_server("brave", url="http://localhost:9000/sse")

@agent.node()
async def web_research(ctx):
    return await ctx.call_tool("brave", "search", query=ctx.request)

@agent.node(depends_on=["web_research"])
async def write_report(ctx):
    return await ctx.llm(f"Write a report from:\n{ctx.deps['web_research']}")

framework = CortexFramework(config=agent.build())
await framework.initialize()

result = await framework.run_session("user_1", "Research vector DB benchmarks")
print(result.response)                       # synthesised answer
print(result.node_outputs["write_report"])   # raw output of one node

Registering a code node flips the agent to static execution — the DAG you declared is the plan. Each node receives a TaskContext with ctx.request, ctx.deps (upstream node outputs), ctx.llm(), and ctx.call_tool(). You still get the wave engine, validation gate, retries, streaming, and session persistence — Cortex just skips the planner. Mix .task() (LLM-routed) and .node() (Python) freely. See Getting Started.

Why teams choose Cortex

Skip months of framework engineering

The orchestration, parallelism, tool integration, streaming, retries, validation, session persistence, and deployment pipeline — it's all in the box. Your Python code stays a thin wrapper. The agent's behavior lives in cortex.yaml, versioned, diffable, reviewable.

Multi-agent composition for free

Any Cortex agent becomes an MCP server in one command. Other agents consume it as a tool. That's the entire inter-agent protocol — standard MCP, nothing custom.

Orchestrator → Research Agent (MCP :8081) → brave-search, wikipedia
             → Code Review Agent (MCP :8082) → github, filesystem
             → Writing Agent (MCP :8083) → document-gen

Each agent scales, deploys, and configures independently. Compose them by adding YAML lines.

Built-in quality gates

Every response passes through a Validation Agent that scores intent match, completeness, and coherence. You set a floor (default: 0.75); responses below it are flagged and remediated. Bad intermediate outputs are retried with feedback before the pipeline moves on.

Catch regressions before users do, not after.

Your agent gets smarter over time

The Learning Engine observes task patterns across sessions. When patterns recur, it stages a delta proposal — a concrete config change you review with cortex delta review and apply in one command. The agent doesn't silently drift; it surfaces what it learned and asks for approval.

What's in the box

How Cortex compares

Who is Cortex for?

What Cortex is not

• Not a low-code builder. It's a Python library — drive it with cortex.yaml or the CortexBuilder API. Either way, config replaces boilerplate, not your code.
• Not an LLM gateway. Bring your own API key.
• Not a vector database. It calls MCP tools that do RAG — it doesn't implement retrieval itself.
• Not a web framework. Cortex runs inside FastAPI/Django/Flask/Click.

Documentation

Community & support

• Issues: file bugs and feature requests on GitHub Issues
• Discussions: ask questions on GitHub Discussions
• Security: report vulnerabilities privately, not in public issues

License

MIT — see LICENSE. Use it commercially, fork it, ship it.

Define once. Deploy anywhere. Let it learn.