• Launch & Positioning:

  • Shipped alongside Pi 1.0 as an experimental new package designed for building durable, malleable, and long-running agent applications across JavaScript runtimes.
  • Complements rather than replaces the terminal-focused Pi coding agent, serving as a lower-level framework/harness where experimental architectural lessons will feed back into the main project.
  • Designed around minimalism and agent-readability, comprising ~15,000 lines of code (~150k GPT tokens / ~250k Claude tokens) without test suites.

• Harness Architecture & Runtimes:

  • A harness manages conversation transcripts, models, parallel tasks, tools, and execution environments.
  • Provides built-in storage backends for SQLite, JSONL, and in-memory stores; implementations avoid Node-specific APIs so they can run in environments like Bun or Cloudflare Durable Objects.
  • Keeps only active transcripts, tasks, and submissions in memory, relying on disk paging and context compaction to handle conversations spanning tens of thousands of messages.
  • Decouples the harness from execution environments (e.g., local Node file access or remote VMs), letting tools and harnesses run on separate machines.

• Failure Recovery & Durability:

  • Every operation is treated as an isolated task that writes checkpoints before progressing, enabling seamless resumption after process kills, deployments, or OOM crashes.
  • Interrupted model calls are re-issued while preserving partial transcripts marked as aborted.
  • Tool execution durability depends on safety semantics: tools flagged as safe to replay rerun automatically, while unsafe operations report interruptions directly to the model.
  • Subagents run inside their own conversations and checkpoints, automatically surviving crashes alongside the parent workflow.
  • Uses unique requestId parameters for exactly-once request submissions.

• Multi-Agent & Conversation Forking:

  • Supports high-concurrency workloads from multiple frontends (e.g., Slack channels and threaded replies) without blocking the parent stream.
  • Features lightweight, copy-on-write conversation branching (forking) that points to parent transcript history without duplicating entries.
  • Allows granular configuration per conversation (different models, instructions, directories, read-only tools, or separate subagent ownership).

• Extension System:

  • Modularity via named extensions bundling system prompt sections, tools, hooks, and tasks.
  • Recomputes prompt sections dynamically before requests while recording diffs in the transcript to preserve prompt-caching behavior across restarts and forks.

Hacker News Discussion

• Market Trends & Architecture:

  • Commenters highlighted a broader industry shift toward durable agent harnesses (e.g., LangChain Deep Agents, Vercel Eve, OpenAI Agents API, Anthropic Managed Agents).
  • Durability, decoupled compute environments, and native multi-player support were cited as the primary drivers over ephemeral local CLI agents.
  • Pi Durable's library-first approach stands out against heavier, "batteries-included" SDKs and managed enterprise platforms.

• State Management & Implementation Trade-Offs:

  • Earendil developers (including Armin Ronacher / the_mitsuhiko and badlogic) discussed the data design, noting they avoided Redux/reducer patterns and Automerge complexity in favor of lower-level, Immer-like draft storage primitives with custom encoding.
  • The transition from Pi's earlier tree-parented transcript entries to chronological immutable lists with ancestry pointers was explained as an architectural simplification to remove awkward flatten/navigation logic.

• External State vs. Agent State Challenges:

  • A major discussion point centered on runner/environment state synchronization (e.g., VM filesystems, browser sessions) during crashes.
  • Participants noted that agent checkpoint recovery does not automatically rewind dirty state in external environments unless actions are declarative/idempotent, handled like traditional workflow engines, or backed by deterministic VM snapshotting.

• Community Projects & Tokenizer Discrepancies:

  • Developers shared related projects exploring durable sandboxing, such as using Dagger OTLP traces to serialize, replay, and migrate long-running sessions across local machines and cloud engines.
  • Users expressed surprise at the large tokenization disparity mentioned in the post (150k GPT tokens vs. 250k Claude tokens for 15k lines of JavaScript).

• Study Scope & Setup:

  • Evaluated 21 model–harness combinations using 7 models across 3 agent harnesses (Claude Code, Codex CLI, and Pi) on two benchmarks: SWE-bench Lite and Terminal-Bench 2.0.
  • Controlled variables by testing on identical sampled tasks, using native high-effort settings, capping attempts at 100 turns, and normalizing direct API token pricing.

• The "Harness Tax" Phenomenon:

  • Changing the harness has minimal effect on task resolution rate (within ±2% on SWE-bench Lite and ~±5% on Terminal-Bench 2.0), but dramatically alters token expenditure (diverging by up to 2×–5× for identical success rates).
  • This overhead is driven by initial context bloat, verbose system prompts, and heavy tool schemas injected into the context window before work begins.

• Minimalist Harnesses Remain Highly Competitive:

  • Pi, a lightweight open-source harness, proved competitive with or superior to heavy proprietary harnesses in both resolution rate and token efficiency.
  • For example, running Claude Fable 5 resolved ~97%–98% of tasks across both Claude Code and Pi, yet Claude Code cost approximately twice as much ($1.33 vs. $0.67 per attempt).

• First-Party Harness Mismatch:

  • Models do not necessarily perform best inside their creator's native harness.
  • In 9 out of 12 head-to-head comparisons across Anthropic and OpenAI models, third-party or alternative harnesses delivered higher success rates than the model provider's default CLI.

• Core Practical Takeaway:

  • Accepting a coding agent's default harness incurs an unnoticed "harness tax" in the form of inflated API bills or premature subscription rate limits.
  • Agent benchmarking should decouple models from scaffolds, treating harness complexity and tooling architecture as separate empirical engineering trade-offs.

Not sure of the truth of the story either @Josh, but thanks for the trip down memory lane. My math teacher gave me that article when I was in the 12th grade because he knew I had been variously killing time in his math classes since 9th grade memorizing the first 8,000 digits of pi and reading for fun.

Good picture (and article) on parts of pi 4

This part needs input from the PI! How do we want to track down the source data and encourage those to be published somewhere?

Actually, he first used π in 1727, and it meant 6.28.., not 3.14..

Best method I’ve seen, so far.

Some people are porting Apple's Swift programming language to the Raspberry Pi. At the time of this post in December 2015, they had the compiler running on RPi 2 with Ubuntu Linux. They did not yet have the Foundation libraries, the Swift Package Manager, or a version for RPi 1, and it was not certain whether it would run on Raspbian Linux.