Compare Opensource Agent Framework: Pi vs Eve vs Deep Agent vs Flue

The open-source AI agent ecosystem has exploded in 2026. What used to be experimental prototypes have matured into production-grade frameworks capable of building autonomous agents that write code, manage files, execute workflows, and collaborate with humans.

But with so many options emerging—each with a different philosophy—choosing the right framework can feel overwhelming. This guide compares four of the most talked-about open-source agent frameworks: Pi, Eve, Deep Agents, and Flue.

Quick Overview

Framework	Language	Origin	Stars	Core Philosophy
Pi	TypeScript	Earendil Inc.	~32K+	Minimal harness, maximum extensibility
Eve	TypeScript	Vercel	New (2026)	Filesystem-first, production built-in
Deep Agents	Python	LangChain AI	~29K	Batteries-included, LangGraph-powered
Flue	TypeScript	Astro Team	~2.9K	Runtime-agnostic, deploy anywhere

1. Pi: The Minimal Agent Harness

Website: pi.dev | GitHub: earendil-works/pi | License: MIT

Pi takes a deliberately minimalist approach to agent building. Rather than baking every feature into the core, Pi provides primitives—extensions, skills, prompt templates, and themes—that you compose to build exactly the agent you want.

Key Features

• Minimal core — keeps system prompts under 1,000 tokens, making it fast on local models and cheap on cloud APIs
• 15+ providers — Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq, Cerebras, xAI, Hugging Face, and more
• Four modes — Interactive (TUI), Print/JSON, RPC (stdin/stdout), and SDK for embedding
• Extension system — TypeScript modules with access to tools, commands, keyboard shortcuts, and events
• Mid-session steering — Submit messages while the agent works; Alt+Enter for follow-ups
• Context engineering — AGENTS.md/SYSTEM.md loading, customizable compaction, topic-based summarization
• Package ecosystem — Install from npm or git; 50+ community extensions available

Architecture

Pi’s architecture is built around a tool-use loop with four core primitives: read, write, edit, and bash. Everything else—sub-agents, plan mode, permission gates, MCP integration—is added via extensions.

# Quick start
curl -fsSL https://pi.dev/install.sh | sh
pi  # Start interactive session

Best For

• Developers who want full control over agent behavior
• Projects that need a lean, fast agent without framework overhead
• Teams building custom agent workflows from primitives

Limitations

• No built-in sub-agents or plan mode (you build or install them)
• Requires TypeScript knowledge for extensions
• Steeper learning curve for non-technical users

2. Eve: The Filesystem-First Framework

Website: vercel.com/eve | GitHub: vercel/eve | License: Open Source

Eve is Vercel’s take on agent frameworks, released in mid-2026. Its defining idea: an agent is just a directory of files. No complex configuration, no boilerplate—just a folder structure that describes who the agent is, what it can do, and what it knows.

Key Features

• Filesystem-first design — Agent definition is a directory tree:

  agent/
  ├── agent.ts          # the model it runs on
  ├── instructions.md   # who it is
  ├── tools/
  │   └── run_sql.ts    # what it can do
  ├── skills/
  │   └── revenue-definitions.md  # what it knows
  └── subagents/
      └── investigator/ # who it delegates to

• Durable execution — Sessions survive crashes and restarts
• Sandboxed compute — Secure code execution environment
• Human-in-the-loop — Built-in approval gates for sensitive actions
• Subagents — Delegate specialized tasks to child agents
• Evals — Built-in evaluation framework
• Vercel-native deployment — vercel deploy ships agents to production unchanged

Architecture

Eve runs on Node.js and treats agents as ordinary Vercel projects. The smallest agent is just two files: a model definition and an instructions file. It supports any LLM provider and integrates with MCP servers.

// agent/agent.ts
import { defineAgent } from "eve";
export default defineAgent({
  model: "anthropic/claude-opus-4.8",
});

Best For

• Teams already in the Vercel/Next.js ecosystem
• Developers who prefer convention over configuration
• Production deployments needing built-in durability and approvals

Limitations

• Newer framework with a smaller community (launched June 2026)
• Tighter coupling to Vercel’s deployment model
• Less flexible than Pi for highly custom workflows

3. Deep Agents: The Batteries-Included Harness

Website: langchain-ai.github.io/deepagents | GitHub: langchain-ai/deepagents | License: MIT

Deep Agents (formerly deepagents) is LangChain’s opinionated agent harness built on top of LangGraph. Where Pi and Eve focus on TypeScript, Deep Agents brings the Python ecosystem’s strengths: LangGraph’s state management, LangSmith’s observability, and the breadth of LangChain’s tool integrations.

Key Features

• Opinionated defaults — Tuned for long-horizon, multi-step work out of the box
• Sub-agents — Delegate tasks to agents with isolated context windows
• Filesystem — Read, write, edit, or search over pluggable backends (local, sandboxed, remote)
• Context management — Summarize long threads and offload tool outputs to disk
• Persistent memory — Pluggable state and store backends for cross-session recall
• Human-in-the-loop — Approve, edit, or reject tool calls before execution
• Skills — Reusable behaviors the agent loads on demand
• MCP support — Bring your own tools or use any MCP server
• Model-agnostic — Works with any LLM that supports tool calling

Architecture

Deep Agents is built on LangGraph, providing streaming, persistence, and checkpointing. The create_deep_agent() function is the main entry point, accepting a model, tools, and system prompt.

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[my_custom_tool],
    system_prompt="You are a research assistant.",
)

result = agent.invoke({"messages": "Research LangGraph and write a summary"})

Best For

• Python teams familiar with LangChain/LangGraph
• Projects needing first-class tracing and observability (via LangSmith)
• Complex multi-agent workflows with persistent state
• Teams wanting a batteries-included solution with minimal setup

Limitations

• Heavier dependency tree (LangChain, LangGraph, LangSmith)
• Python-only (no TypeScript variant for frontend teams)
• Opinionated defaults may not suit all use cases

4. Flue: The Runtime-Agnostic Framework

Website: flueframework.com | GitHub: withastro/flue | License: Apache-2.0

Flue comes from the team behind Astro and takes a unique approach: build once, deploy anywhere. It wraps a harness (Pi) with project structures, conventions, integrations, and developer experience that make agents productive to build and deploy across multiple runtimes.

Key Features

• Runtime-agnostic — Deploy to Node.js, Cloudflare (Durable Objects), GitHub Actions, GitLab CI/CD, or any VM/container
• Built on Pi — Uses the Pi agent harness under the hood, giving you the full harness experience
• Durable execution — Sessions resume automatically after crashes, restarts, and deploys
• Sandbox API — Secure environment for agents to run commands and edit files
• Skills system — Package expertise that agents load when needed
• MCP integration — Connect to thousands of tools via Model Context Protocol
• Durable Streams — Every session is recorded to a replayable log
• Multi-agent support — Run one agent or a multi-agent swarm on the same foundation
• Observability — Export traces to OpenTelemetry, Braintrust, Sentry, or custom observers

Architecture

Flue has a three-layer stack: the framework (Flue), the harness (Pi), and the runtime/platform (Cloudflare Agents SDK, Node.js, etc.). When deployed to Cloudflare, each agent becomes a Durable Object with isolated storage and compute.

// .flue/agents/hello-world.ts
import type { FlueContext } from '@flue/sdk/client';

export default async function ({ init, payload }: FlueContext) {
  const agent = await init({ model: 'anthropic/claude-sonnet-4-6' });
  const session = await agent.session();
  // Agent logic here
}

Best For

• Teams needing multi-cloud deployment flexibility
• Projects that want Pi’s harness without Pi’s terminal-first UX
• Production systems requiring durable execution and session recovery
• Astro/JavaScript teams looking for a familiar framework feel

Limitations

• Smaller community than Pi or Deep Agents (~2.9K stars)
• Newer framework, still stabilizing APIs
• Additional abstraction layer over Pi may add complexity

Head-to-Head Comparison

Language & Ecosystem

Framework	Primary Language	Runtime	Package Manager
Pi	TypeScript	Node.js	npm/pnpm/bun
Eve	TypeScript	Node.js (Vercel)	npm
Deep Agents	Python	Python 3.11+	pip/uv/poetry
Flue	TypeScript	Node.js/Cloudflare	npm/pnpm

Core Philosophy

Framework	Philosophy	Analogy
Pi	”Primitives, not features”	Like Unix—small tools composed together
Eve	”An agent is a directory”	Like Next.js—convention over configuration
Deep Agents	”Batteries included”	Like Django—opinionated and complete
Flue	”Write once, deploy anywhere”	Like Astro—framework with runtime flexibility

Feature Matrix

Feature	Pi	Eve	Deep Agents	Flue
Durable execution	Via extensions	Built-in	Via LangGraph	Built-in
Sandboxing	Via extensions	Built-in	Via pluggable backends	Built-in
Sub-agents	Via extensions	Built-in	Built-in	Built-in
Human-in-the-loop	Via extensions	Built-in	Built-in	Via tools
MCP support	Via extensions	Yes	Yes	Yes
Observability	Via extensions	Vercel Analytics	LangSmith	OpenTelemetry
Model providers	15+	Any LLM	Any LLM (tool calling)	Any LLM
Deployment targets	Terminal/SDK	Vercel	Any Python host	Multi-cloud
Community size	Large (~32K+)	Growing	Large (~29K)	Growing (~2.9K)

When to Choose Each Framework

Scenario	Best Choice	Why
Maximum control & minimal overhead	Pi	Primitives you compose yourself
Vercel/Next.js production deployment	Eve	Native Vercel integration, filesystem-first
Python team with LangChain experience	Deep Agents	LangGraph power, LangSmith observability
Multi-cloud or edge deployment	Flue	Runtime-agnostic, Durable Objects on CF
Quick prototype with minimal config	Eve	Two files and you’re running
Custom agent architecture from scratch	Pi	Build exactly what you need
Enterprise with compliance requirements	Deep Agents	Human-in-the-loop, persistent memory, tracing

The Framework Stack: How They Relate

An important nuance: these frameworks aren’t always competitors. They often serve different layers of the stack:

┌─────────────────────────────────────────┐
│           Framework Layer               │
│  (Flue, Eve) — project structure, DX    │
├─────────────────────────────────────────┤
│           Harness Layer                 │
│  (Pi, Deep Agents) — agent loop, tools  │
├─────────────────────────────────────────┤
│           Runtime Layer                 │
│  (Cloudflare, Node.js, LangGraph)       │
└─────────────────────────────────────────┘

Flue literally wraps Pi as its harness. Eve could theoretically use Pi or Deep Agents as its underlying engine. Deep Agents wraps LangGraph. Understanding this stack helps you see that the choice isn’t always “either/or”—it’s about which layer you need to customize.

Conclusion

The open-source agent framework space in 2026 is maturing rapidly, but there’s no one-size-fits-all winner:

• Pi wins on extensibility and minimalism. If you want to build exactly the agent you envision from primitives, Pi is your foundation.
• Eve wins on developer experience and convention. If you want an opinionated framework that “just works” with Vercel, Eve is the fastest path to production.
• Deep Agents wins on batteries-included completeness. If you’re a Python shop with LangChain experience, Deep Agents gives you everything out of the box.
• Flue wins on deployment flexibility. If you need to deploy agents across multiple clouds or edge platforms, Flue’s runtime-agnostic approach is unmatched.

The best framework is the one that fits your team’s language preference, deployment needs, and level of control. Many production systems will combine multiple frameworks across the stack—using Pi or Deep Agents as the harness, wrapped by Flue or Eve for project structure and deployment.

The agent revolution isn’t coming—it’s here. Pick your framework and start building.