Agent Orchestration vs Agent Frameworks: What's the Difference?
Mentiko Team
The AI agent space has a terminology problem. "Framework" and "orchestration platform" get used interchangeably, but they solve fundamentally different problems.
If you're evaluating tools for your agent stack, understanding this distinction will save you months of building the wrong thing.
What an agent framework does
An agent framework helps you build a single agent. It provides:
- LLM abstraction -- talk to Claude, GPT-5.4, Gemini through one API
- Tool use -- give your agent access to functions, APIs, databases
- Memory -- conversation history, vector stores, context windows
- Prompting -- templates, chains of thought, structured outputs
Examples: LangChain, LlamaIndex, Semantic Kernel, Haystack.
These are libraries. You import them into your code, write a Python script, and run it. The output is one agent that does one thing.
What an orchestration platform does
An orchestration platform coordinates multiple agents working together. It provides:
- Chain definition -- which agents run in what order
- Event routing -- agent A triggers agent B through events
- Execution management -- launching, monitoring, and recovering agents
- Scheduling -- run chains on cron, via webhook, or on-demand
- Monitoring -- real-time dashboards, logs, run history
- Multi-tenancy -- teams, roles, isolation between organizations
Examples: Mentiko, Temporal (for general workflows), Airflow (for data pipelines).
The output is a system where multiple agents collaborate on complex tasks without human intervention.
The confusion
The confusion exists because some frameworks added orchestration features (LangGraph, CrewAI crews), and some orchestration platforms include agent-building capabilities.
But the core distinction remains: are you building one smart agent, or coordinating many agents into a workflow?
When you need a framework
You need a framework when:
- You're building a chatbot or single-purpose AI feature
- Your agent needs to call tools and manage its own state
- You want fine-grained control over prompts and model parameters
- Your project is one Python script or one API endpoint
- You're prototyping and don't know what your agent system looks like yet
A framework is the right starting point. Build one agent, get it working, understand the problem.
When you need orchestration
You need orchestration when:
- You have 2+ agents that need to work together
- Agent A's output is agent B's input
- You want agents to run on a schedule without you
- You need monitoring and alerting when things fail
- Different team members manage different agents
- You want to version control your workflows
- You need audit trails and execution history
This is where frameworks fall short. They weren't designed for coordination. Bolting orchestration onto a framework is like bolting a web server onto a calculator -- technically possible, architecturally wrong.
The two-layer stack
The mature approach is to use both:
Layer 1: Agent framework -- build individual agents with LangChain, your own code, Claude Code, whatever works. Each agent is a standalone capability.
Layer 2: Orchestration platform -- coordinate those agents with Mentiko. Define chains, set triggers, schedule runs, monitor execution.
This separation has real benefits:
- Swap agents without rewiring. Replace your LangChain agent with a Claude Code agent. The chain doesn't care -- it just triggers the next agent when the event file appears.
- Mix technologies. Agent A is Python, agent B is a shell script, agent C is a Rust binary. The orchestration layer treats them all the same: processes that read input and write output.
- Scale independently. Your agent code and your orchestration logic evolve at different rates. Separating them means you can improve one without breaking the other.
How Mentiko fits
Mentiko is an orchestration platform. It doesn't replace your agent framework -- it coordinates the agents your framework builds.
You define chains in JSON: which agents run, what events they listen for, what events they emit. Mentiko launches them in isolated PTY sessions, watches for completion events, triggers the next agent, and gives you a real-time dashboard to monitor everything.
Your agents can be anything: a Python script using LangChain, a Claude Code session, a shell script that calls an API, a Rust binary that processes data. Mentiko doesn't care what's inside the agent. It cares about the coordination between them.
That's the difference between a framework and an orchestration platform. And it's why you probably need both.
Ready to add orchestration to your agent stack? Get started with our tutorial or join the waitlist for early access.
Get new posts in your inbox
No spam. Unsubscribe anytime.