The Push: May 24th, 2026
Persistent agent runtimes, explorable code knowledge graphs, and portable AI coworkers for teams with real workflows
Pi: The Agent Stack, Unbundled
github.com/earendil-works/pi | License: MIT
OpenAI, Anthropic, Google, local models, Slack workflows, terminal UI, web UI, coding agent CLI. That list usually means one thing: a pile of half-connected demos. Pi is interesting because it feels like someone got annoyed with that fragmentation and built a single place where an agent can actually live, not just answer prompts. The result is less “chatbot wrapper,” more operating substrate for AI work. In a market full of shiny assistants, that distinction matters, because the boring infrastructure layer is usually where the durable value hides.
The Drop: Too Many Agents, Not Enough System
Every AI product team seems to hit the same wall. The model works in a playground, the demo lands, then reality shows up. One customer wants Anthropic, another needs OpenAI, an internal team wants a terminal workflow, support wants Slack, and suddenly “the agent” is actually five different apps glued together with inconsistent state and duplicated logic.
Pi exists because that sprawl gets expensive fast. The pain is not only model switching, though pi-ai, its unified multi-provider LLM layer, clearly tackles that. The deeper problem is that agent products often rebuild the same runtime pieces again and again: streaming, tool calls, session history, UI rendering, provider abstraction, and deployment plumbing. Every new surface area becomes another bespoke integration.
That fragmentation also kills iteration speed. When the terminal experience, chat automation, and backend runtime all evolve separately, no one really knows where behavior comes from or how to improve it. Pi reads like a reaction to that mess. Instead of treating coding agents, chat bots, and model APIs as separate categories, the repo treats them as one stack with shared state, shared runtime rules, and shared interfaces. Honestly, that framing is the whole point.
The Stack: TypeScript All the Way Down
Under the hood, Pi is a TypeScript monorepo built around three core packages: pi-coding-agent for the CLI, pi-agent-core for runtime and state management, and pi-ai for multi-provider model access. A custom pi-tui library handles differential terminal rendering, while Slack and web-facing layers sit on top of the same agent substrate.
The Sauce: One Runtime, Many Front Doors
Plenty of repos can call multiple models. Pi gets interesting with the Agent Harness, a persistent runtime that treats sessions, tool use, streaming output, and context compaction as first-class system concerns instead of UI features bolted on later.
That matters because agents break in very specific ways. Context windows fill up. Tool output gets noisy. Conversations fork. A user switches from terminal to another interface and expects continuity. Pi’s architecture seems built around that lived reality. The runtime keeps durable session records, supports branch-style summarization when history gets too large, and emits event streams that different clients can subscribe to. In other words, the agent is not the chat box. The agent is the stateful process underneath, and the chat box is just one renderer.
The custom pi-tui library reinforces that thesis. Differential rendering means the terminal updates only the parts that changed, which sounds minor until you realize agents are fundamentally streaming systems. If the interface repaints clumsily, the whole experience feels laggy and incoherent. Pi treats interaction latency as a design problem, not just an inference problem.
There is also a subtle but very smart choice in the repo’s session-sharing posture. Maintainers actively encourage publishing real agent sessions as training data. That turns usage into feedback infrastructure. Not telemetry in the ad-tech sense, but a corpus of actual tasks, tool sequences, failures, and recoveries. If that loop compounds, Pi is not just an agent toolkit. It is a machine for learning how agents behave in the wild.
The Move: Build Once, Ship Across Surfaces
Founders and product teams could use Pi as the backbone for any workflow where an agent needs memory, tools, and multiple ways to show up. One path is obvious: stand up a coding assistant that works in the terminal for power users, then reuse the same runtime for a Slack bot that handles lightweight requests from the broader team. Same session model, same provider abstraction, less duplicated product logic.
Another angle is vendor optionality. Teams experimenting with model costs or compliance constraints can plug different providers behind one interface, then keep the rest of the product stable. That is a strategic advantage, not just engineering neatness. Model pricing changes, rate limits hit, safety policies shift. Pi gives a cleaner place to absorb those shocks.
There is also a hidden wedge for internal tools. A company can wrap domain-specific tools, prompts, and permissions into one controlled agent runtime instead of buying a black-box assistant and hoping it behaves. That makes Pi useful for ops workflows, research copilots, support triage, and internal developer platforms. The upside is not “build an AI app.” The upside is owning the behavior layer before it calcifies into someone else’s product.
The Aura: Expectation Catches Up to Capability
People are getting less patient with AI that forgets, stalls, or behaves differently depending on which surface they opened. Once an agent can carry context across sessions, call tools reliably, and appear in terminal, chat, or web without becoming a different personality each time, the baseline expectation changes.
Pi points at that new normal. Software starts feeling less like isolated interfaces and more like persistent coworkers with multiple entry points. Maybe that sounds ambitious, but the behavior shift is already visible. Users do not want another clever prompt box. They want continuity, accountability, and the sense that the system is actually there when work resumes.
The Play: Infra Wedge, Application Upside
This looks more like a 0-to-1 control layer than a slightly better coding agent. TAM is broad because the wedge is not “developer tool for code gen,” it is cross-surface agent infrastructure for any company building persistent AI workflows. The repo’s 53,745 stars are an early PMF signal, but the stronger signal is architectural ambition plus adjacent components, runtime, UI, provider layer, deployment hooks, all living in one stack. The moat is not pure code. It is execution speed, workflow data from real sessions, and switching costs once teams bake agent behavior into ops.
Winners:
Aider: Faster product expansion compounds because a strong open agent runtime raises user expectations beyond single-surface coding help.
Glean: Broader enterprise AI adoption gets easier when persistent agent behavior becomes normal, increasing LTV for platforms already embedded in company knowledge.
Microsoft: Deeper demand for agent-native infrastructure strengthens Azure and GitHub’s position as buyers look for controllable, multi-interface AI systems.
Losers:
Factory: Narrower differentiation erodes if coding-agent startups cannot own the runtime layer and become feature bundles on top of interchangeable stacks.
Harvey: Higher customer expectations around persistent, tool-using workflows make vertical AI suites work harder to justify premium CAC without more transparent infrastructure.
Salesforce: Bundled assistant value weakens when buyers realize the sticky part is agent orchestration and memory, not the CRM vendor’s default AI wrapper.
tl;dr
Pi turns the messy parts of agent products, model routing, session state, tool execution, and interface rendering, into one coherent stack. The clever bit is the persistent runtime underneath multiple surfaces. Worth a look for anyone building AI products that need to feel consistent, controllable, and durable.
Stars: 53,748 | Language: TypeScript
