Pi vs Oh My Pi vs Prime Agent vs jcode! (The AI Harness War)

Summary of technological concepts & product features (Pi vs Oh My Pi vs Prime Agent vs jcode!)

Core thesis: “Harness” matters more than model choice

• The video argues that model quality (e.g., Opus vs GPT vs GLM) is only one layer.
• A harness is the software wrapper between the user and the model, determining:
  • which tools the model can call (file read/edit, shell commands, codebase search)
  • how context is managed over long sessions
  • how memory is stored/used across turns/sessions
  • how orchestration works (whether multiple agents can run and coordinate)
• Result: the same model can behave very differently depending on harness quality.
• The video also claims harness improvements compound faster than model progress because harnesses can be updated weekly.

Trust & auditability advantage of open-source harnesses

• Proprietary coding tools (examples mentioned: “clawed code,” Cursor, Windsurf) are described as “sealed boxes”, meaning users can’t verify tool calls or file edits.
• Open-source harnesses let developers inspect:
  • how prompts are constructed
  • how tool-call payloads are built
  • how edits are applied
• This is positioned as important for security and auditability.

---

The four open-source harnesses compared

1) Pi (foundation / minimal)

Source: Mario Zegner (Badlogic Online), MIT license.

Positioning

• Presented as the root foundation for multiple later projects.
• Built through deliberate minimalism:
  • implements core harness functionality
  • leaves advanced features as primitives for others/community to add

Key features

• Runs locally in the terminal with no cloud backend.
• Connects directly to model providers via API keys or subscriptions.
• Supports 15+ model providers, with the ability to switch providers mid-session.
• Tree-based sessions (branching conversation rather than linear threads).
• Multiple runtime modes:
  • interactive terminal
  • print/JSON mode for scripting
  • RPC mode
  • SDK mode for building tools on top of Pi
• Governance/licensing note:
  • Mentions an RFC (“RFC000015”) committing Pi’s core to remain MIT licensed permanently, while allowing “fair source” licensing on additional/proprietary layers.

Role in the ecosystem

• The video emphasizes Pi is the “trunk”:
  • OpenClaw is said to be built on Pi
  • Oh My Pi is explicitly a fork of Pi

---

2) Oh My Pi / AMP (Pi fork → IDE-grade surface in terminal)

Source: Kimbolic (1357 online), fork of Pi.

Design philosophy

• Opposite of Pi’s minimalism: “coding-first surface” aiming for an IDE-like experience immediately.

Key features

• Rust core (~100k+ lines of code) for performance.
• Language Server Protocol (LSP) integration:
  • diagnostics, reference lookup
  • safe renames
  • code actions
• Debugger attachment via Debug Adapter Protocol (DAP):
  • supports LLDB/DLV/debugp
  • enables real breakpoints and stepping
• Hashline edits
  • anchors edits to a hash of the file state the model saw
  • rejects edits if the file changed to avoid corrupting code
• Stream rules
  • token-by-token monitoring of model output during streaming
  • can correct course immediately when constraints are violated
• Hindsight memory (described as proprietary to AMP)
  • retains/compresses useful info across sessions
• First-class sub-agent orchestration inside the core (not bolted on)
• Onboarding/config import
  • on first run, auto-loads settings from many existing tool formats (examples listed include Cursor-style files, Windsurf, Gemini/Copilot-related configs, code editing tool configs, VS Code settings, etc.)
• TypeScript extension API
  • enables custom tools using the same tool registry/commands/hotkeys and terminal primitives as built-ins.
• Licensing: MIT, no hosted services/subscriptions.

Stated goal

• Framed as a direct open-source alternative/answer to Claude Code with transparent behavior.

---

3) Prime Agent (Pi fork → experimental, self-modifying architecture)

Source: Prime Intellect (major funding; video cites a $130M series and >$150M total).

Lineage

• Built directly on Pi, but diverges architecturally.

Key architectural ideas

1. Recursive Language Model (RLM)
   • Instead of fixed tool schemas, the model can treat context as something it programs over.
   • Running tasks happens inside a persistent Python environment.
   • Sub-agent launching is described as function calls, so longer sessions become a “programming problem” rather than purely memory/context juggling.
2. Continual Harness
   • Unlike many systems where scaffolding/prompting/memory instructions are fixed by developers,
   • Continual harness treats those scaffolds as durable state the agent can create/read/update/delete.
   • The video describes this as enabling the agent to:
     • write code
     • test it
     • learn from results
     • modify its own operating instructions autonomously

Benchmark claims & skepticism

• Biggest cited result: 95.5% on Arc AGI 3 with Opus 5.
  • Video notes it sits slightly above a “human expert baseline” of 95.4%.
  • Reports multiple runs with a best score near 99.97%.
• Token-efficiency claim:
  • Prime Agent allegedly uses fewer tokens than traditional harnesses by operating via functions over data rather than long chains of tool calls.
• Additional evaluation suite (context benchmarks):
  • Claims Prime Agent beats Pi’s minimal form on 8/9 tests and edges other tools on 6/9 in several configurations (GLM 5.2 / Claude Code / Codeex / GPT 5.6 mentioned).
• Case studies mentioned:
  • emulator building (Rust-based Sega Genesis / Game Boy Color emulator from specs)
  • GPU kernel generation verified by a “kernel guard”
  • Factorio long-horizon test reaching a “production score” above 100,000

Important caveat emphasized

An independent reviewer is said to have: - inspected/opened source and built locally - but did not run paid end-to-end sessions and did not reproduce Prime Intellect’s benchmark suite

Therefore, 95.5% is treated as company-reported, not third-party verified yet.

Another caveat: the project is extremely new (public launch date given as Aug 5, 2026), so less real-world battle testing than Pi/AMP.

---

4) jcode! (“Code”) (independent → designed for running many agents at once)

Source: Jeremy Huang (Solo Systems), Rust-based, not a Pi fork.

Problem focus

• Performance at scale: enabling many concurrent agents without exhausting RAM or slowing down.

Key features

• Swarm mode
  • multiple jcode agents operate in the same repository simultaneously
  • coordination/notification when files change so agents don’t work from stale reads
  • agents can message each other directly or broadcast updates
• Autopoke
  • if an agent ends a turn with unfinished tasks, the harness re-prompts automatically rather than ending early
• Built-in long-term memory
  • each conversation turn is embedded into a semantic memory graph
  • future turns query this automatically
• Session resume across other tools
  • sessions can be resumed from Claude Code / Cursor / Codeex / Pi interruptions (as described)
• Self-die/self-dee mode
  • allows the agent to modify its own source code
• Model-agnostic
  • you supply your own model/provider (via your existing keys/subscriptions)

Performance claims & caveats

• Performance: very fast “time to first frame” claim (e.g., ~14 ms vs ~3437 ms for another tool in the video).
• Memory footprint: claims of major reductions are mentioned.
• Growth: GitHub stars increasing quickly.

Two important gray-area caveats highlighted

1) OAuth routing risk (“gray area”) - jcode can log in using existing Claude Code / Codeex OAuth credentials. - Video claims this conflicts with Anthropic/OpenAI ToS and that users reported account bans. - Safer approach: using your own API keys directly. - Risk approach: routing subscriptions through a third-party harness via OAuth.

2) Benchmark methodology concerns - speed/memory claims circulated without published methodology. - video advises treating performance claims like other unverified benchmark claims until testing process is confirmed.

---

Side-by-side conclusion: what each tool is “for”

• Pi: minimal, provider-agnostic foundation; best when you want maximum control and extensibility.
• Oh My Pi: Pi fork optimized for IDE-grade terminal workflows (LSP + debugging, rich config import).
• Prime Agent: Pi fork optimized for experimental autonomous reasoning/operation (RLM + continual harness); best if you’re comfortable with a very new, research-heavy tool and headline benchmarks that aren’t independently verified (yet).
• jcode!: independent Rust project focused on scaling to many parallel agents (swarm mode, coordination, low overhead); use carefully given OAuth/login risk and some unverified methodology behind performance claims.

---

Main speakers / sources (as stated or implied)

• Mario Zegner (Badlogic Online) — creator of Pi
• Kimbolic (1357 online) — creator of Oh My Pi (AMP)
• Prime Intellect / Prime Intellect team — creators of Prime Agent (described via company funding and research context)
• Jeremy Huang (Solo Systems) — creator of Code / jcode!
• Channel narrator/reviewer voice — the video’s analyst (host) who compares and adds skepticism; also mentions “an independent reviewer” who inspected Prime Agent’s code but didn’t reproduce benchmarks end-to-end.