vs other agent frameworks

The agent space has many credible primary abstractions. agentfootprint sits above the choice — built on footprintjs, which gives us every one of those abstractions out of the box, so we used the budget those abstractions would have cost us to invest deeply in the injection loop — the layer every other framework leaves to the developer.

The agent space — what each framework abstracts

Framework	What it abstracts
LangChain	Pipelines of composable components
LangGraph	State machines of nodes and edges
CrewAI · AutoGen	Crews of role-playing agents
Mastra · Genkit · Pydantic AI	Typed full-stack bundles
DSPy	Compiled prompts
Inngest AgentKit	Durable workflows

We didn’t have to choose between them. agentfootprint is built on footprintjs — the flowchart pattern for backend code. footprintjs gives us every one of those abstractions out of the box:

Capability	What footprintjs hands us
Composition	Sequence · Parallel · Conditional · Loop
State machines	The ReAct loop is a flowchart
Multi-agent crews	Compose Agents through control flow — no special class needed
Durable workflows	pauseHere() plus JSON-portable resume()
Typed observation	57+ events for free, because the framework owns the loop

So we used the budget those abstractions would have cost us to invest deeply in something they all leave to the developer: the injection loop.

In one sentence per framework

• vs LangChain — agentfootprint has a 2-primitive + 4-composition substrate; LangChain ships a class-per-paper. If you’re maintaining a “pile of LangChain abstractions” codebase and the abstractions feel like the problem, switch.
• vs LangGraph — both treat agents as graphs; agentfootprint records every traversal as a typed event for free (because the framework owns the loop, not you) and adds Injection = slot × trigger × cache as a first-class layer. If you’ve found yourself instrumenting LangGraph manually or building per-node prompt assembly by hand, switch.
• vs CrewAI / AutoGen — agentfootprint has no Crew / Agent / Task separate primitives; multi-agent IS composition of single agents through Sequence/Parallel/Conditional/Loop. If role/goal/backstory framing feels like ceremony, switch.
• vs Mastra / Genkit / Pydantic AI — those are full-stack bundles (DB + auth + workflows + agents). agentfootprint is the agent layer only. Pick those if you need the bundle; pick agentfootprint if you have a stack and want the best context-engineering primitive.
• vs DSPy — DSPy compiles prompts at training time; agentfootprint composes injections at inference time. Different problems. Use DSPy when you want the framework to optimize the prompt; use agentfootprint when you want to control which content lands where, when, and why.
• vs Inngest AgentKit — Inngest is durable workflows with agent helpers; agentfootprint is agents with durable workflow primitives (pauseHere, resume). If you already run Inngest, keep it for queue/cron and call agentfootprint inside steps. If you don’t, agentfootprint’s pause/resume covers most of what you’d reach for.

What agentfootprint claims

Claim	Where it shows
Context engineering as a first-class runtime layer	Why agentfootprint? — Injection primitive
Every LLM call backtracks to what / who / when / how	4 backtrack questions
Every code block in our docs is a real, runnable file in CI	The Phase 1 CodeFile + region marker infrastructure
Causal memory — the trace is a cache of the agent’s thinking	Causal deep dive
Every named pattern is a recipe, not a class	Patterns
Mocks-first dev → real-infra prod is a one-line swap per boundary	Quick Start
Multi-tenant isolation enforced at the storage boundary	Memory guide
Rules-based reliability gate around every LLM call	Reliability gate (v2.11.5+)

What agentfootprint does NOT claim

• We are not the only framework with multi-agent. CrewAI / LangGraph / AutoGen / Inngest all have it. Ours has a smaller surface; pick on taste.
• We are not the only framework with memory. Most have some flavor. Ours is the only one with Causal type (decision-evidence persistence) — see Memory guide.
• We are not the only framework with observability. Most ship spans / events. Ours is typed + emitted during DFS traversal so it’s structured + complete by construction, not collected after the fact.
• We are not the only framework with reliability primitives. LangGraph’s Pregel does retry; LangChain’s with_retry/with_fallbacks exist. Ours adds first-chunk arbitration (streaming-aware) and routes via declarative rules — see Reliability gate.

When NOT to use agentfootprint

• You need vector search in your memory store today. Ships InMemory + Redis + AgentCore. Vector-search adapters (pgvector / Pinecone / Qdrant) are roadmap items tracked in GitHub.
• You need full multi-modal (images, video) in messages. LLMMessage.content is string today.
• You’re already happy with your current framework’s abstractions and your team is shipping. Don’t switch on hype.
• You want a managed runtime / dashboard. We’re a library, not a platform. Bring your own Lambda / container / cron.

Migration

• From LangChain (v0.0.x → v0.3+ era) — most LangChain agent code maps to Agent.create({ provider }).tool(...).build(). Tools are defineTool({ name, description, inputSchema, execute }). Memory becomes defineMemory({ type, strategy, store }).
• From LangGraph — StateGraph nodes → Sequence steps; conditional edges → Conditional; the rest of the wiring evaporates. Compositions are typed; no START / END constants needed. Per-node with_retry decorators map to .reliability({...}) rules at the agent level.
• From CrewAI / AutoGen — Crew of agents with tasks → Sequence(researcher, writer, editor). Roles + goals → system prompts (or Steering injections). Tools work the same way; no Task class.
• From DSPy — your DSPy-compiled prompt is a Steering injection in agentfootprint (always trigger, system slot). DSPy still does the optimizing offline; agentfootprint does the runtime composition.

Honest comparison

Concern	LangChain	LangGraph	CrewAI	agentfootprint
Surface area	Large; class-per-paper	Mid; graph-DSL	Mid; role-based	Small; 2 primitives + 4 compositions
Context engineering as 1st-class	Manual prompt construction	Per-node prompt assembly	Role/goal/backstory text	Injection = slot × trigger × cache
Per-iteration recomposition	Static prompts	Static per-node	Static	Dynamic ReAct — slots recompose every iteration
Observability	Manual instrumentation	Spans (LangSmith)	Spans (own service)	Typed events emitted during traversal (57+)
Cross-run “why?” replay	Not built in	Not built in	Not built in	Causal memory (decision-evidence persistence)
Test story	Mocks possible	Mocks possible	Limited	Mocks-first by design — mock({replies}), mockMcpClient, InMemoryStore
Multi-tenant isolation	Caller responsibility	Caller responsibility	Caller responsibility	Enforced at every store boundary via MemoryIdentity
Reliability semantics	with_retry on stream skips retry	Pregel atomic-node retry (duplicate tokens)	Bring-your-own	First-chunk arbitration + rule-driven retry/fallback/fail-fast

Next steps

• Quick Start — first agent in 5 minutes
• Why agentfootprint? — the bug-class argument with worked examples
• Key Concepts — the 5-layer taxonomy
• Causal memory deep dive — the differentiator