Agent Orchestration · Same Problems, Different Philosophy

LangChain×lionagi

lionagi has been built continuously since 2023. Both stacks answer the same eight architectural questions — with opposite instincts about who owns the loop, what counts as a model, and where the system ends.

Both Python · LangChain MIT · lionagi Apache-2.0 shared shape philosophy splits ↓
LangChain / LangGraphv1.0
lionagiv0.27
langchain-core chat models
standard content blocks · ModelProfile capability metadata
Model
Interface
iModel
chat APIs and coding-agent runtimes (claude-code, codex, gemini) behind one interface
BaseMessage family · typed state
TypedDict / Pydantic schemas → channel inference
Messages
& State
RoledMessage as graph Node
Pile / Progression typed, UUID-keyed collections
@tool · StructuredTool · ToolNode
schema from function signature · parallel execution
Tools
Action manager · typed contracts
function tools + MCP client integration
create_agent + middleware stack
wrap_model_call / wrap_tool_call · summarization, HITL, subagents as middleware
Agent
Runtime
Branch + operations
operate() · ReAct() / ReActStream() · communicate()
StateGraph → Pregel runtime
BSP super-steps over typed channels · deterministic task IDs for replay
Orchestration
Session → Session.flow() DAG
OperationGraphBuilder · dependency-aware multi-branch execution
Checkpointers · BaseStore
SQLite / Postgres savers · long-term memory store
Persistence
SQLite + filesystem hybrid
companion substrate: khive — Rust knowledge-graph database
interrupt() · HumanInTheLoopMiddleware
pause → approve / edit / resume via Command
Human-
in-the-Loop
Approval-gated actions
pre / post tool-execution hook policies
Callbacks · tracers → LangSmith
run trees, spans, evals
Observability
Run telemetry → Lion Studio
Python + Rust engines observed in one pane

◐Where the philosophy splits

Same problem, opposite instinct — this is the fresh perspective, not a clone.
Who owns the loop?
LangChain
Declare a StateGraph, compile it; the Pregel runtime executes it in BSP super-steps. The framework owns control flow — you extend it through middleware.
lionagi
No compiled artifact. Operations are plain async Python you compose; the DAG builder is opt-in. You own control flow — the framework supplies primitives.
What counts as a model?
LangChain
Chat-completion APIs, wrapped uniformly with standard content blocks and per-model capability profiles.
lionagi
Anything that can take a turn: chat APIs and whole coding-agent runtimes (claude-code, codex, gemini) behind one iModel — orchestrate agents like models.
Where does trust live?
LangChain
Human-in-the-loop as a feature: interrupt() pauses a run, middleware gates tool calls inside the app.
lionagi
Governance as the spine: every orchestration step gate-able, policy-bound and evidence-tracked — built for autonomous fleets, not only copilots.
Where does the system end?
LangChain
A Python framework ringed by a hosted platform: LangSmith tracing, LangGraph Platform deployment.
lionagi
A polyglot open stack: Python orchestration over khive, a Rust knowledge-graph database, with self-hosted observability (Lion Studio).

The wider field

Four answers to agent orchestration — each with a different center of gravity.
LangGraphv1.0 lionagiv0.27 LlamaIndex AG2AutoGen fork
Core abstraction StateGraph + typed channels Branch + operations AgentWorkflow + event-driven steps ConversableAgent + group chat
Control flow compiled graph · BSP super-steps your async Python · opt-in DAG typed event streams between steps conversation turns among agents
Center of gravity agent graphs + hosted platform governed, multi-engine orchestration data & RAG first: indexes, query engines multi-agent conversation (MSR lineage)
Human-in-the-loop interrupt() + Command resume approval-gated hook policies HITL events in workflows human-input mode per agent
Grounded in source: AST-level digest of langchain-ai/langchain + langgraph (July 2026); LlamaIndex & AG2 from current docs and adapter work.
lionagi: github.com/ohdearquant/lionagi · author Haiyang (Ocean) Li