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 / LangGraph v1.0
lionagi v0.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