Self-Compact Pi Agent: ZERO HYPE Agentic Coding Devlog

Summary: Technological Concepts & Product/Agent Features

Problem tackled: agent context windows

• Long-running autonomous coding agents eventually run out of context, leading to:
  • Reduced performance (often called “context rot”)
  • Higher costs
• The “classic agent problem” is framed as: the context window is a precious resource, yet engineers currently lack strong mechanisms to control and manage it.

Core solution: a “self-compacting” PI coding agent

• The agent is designed as a context-aware system with a dedicated tool that lets it decide when to compact its own context (rather than relying solely on provider/tool defaults).
• Motivation: for out-of-loop/autonomous workflows—such as swarms of agents running for hours—compaction should occur at the best time to maintain quality and prevent runaway costs.

Key feature: agent-controlled compaction with thresholds

The agent supports three compaction trigger levels:

1. Notice level (soft)
2. Warning level (more urgent)
3. Force compaction level (hard cutoff)

Additional behavior:

• Each threshold uses custom compaction prompts, instead of baked-in defaults from other tools.

Prompt engineering + harness engineering

The approach emphasizes that many agent coding tools support compaction, but the author claims it can be improved by:

• Taking full control of compaction prompts
• Overriding default compaction messages
• Using human-in-the-loop commands for testing, such as:
  • Viewing thresholds
  • Manually forcing compaction

Workflow contract (plan → build → verify)

• The agent’s execution is governed by structured prompt content:
  • A draft/plan phase is created first by the human using a markdown “plan” file
  • Agents then run a plan → build → verify sequence

“Definition of done” / grading rubric in prompts

The agent is instructed with:

• Definition of done: a clear end state and rules for when to stop
• Grading rubric / constraints to keep the model within expected workflow and file boundaries

Strict guardrails include:

• Instant failure if deliverables are written outside the working duration / project area
• Instant failure if the agent reads files outside its assigned scope (e.g., other agents’ app directories)
• Tools outside allowed directories may be permitted only if safe (e.g., temp files), and failures must stop/report

UI concept: context bar with markers

A UI element (“context bar”) displays context utilization and threshold markers:

• Cache/free context
• Notice marker
• Warning marker
• Hard cutoff marker

This UI is used as part of completion tracking aligned with the “definition of done.”

Configurable compaction thresholds + cost-aware defaults

• Thresholds can be specified as either:
  • Percentages, or
  • Token amounts (including suffixes like thousands/millions)
• The workflow accounts for model pricing/cost dynamics (e.g., pricing changes around certain context-size marks), aiming to:
  • Avoid cost spikes
  • Still complete work

Dedicated “self-compact” tool behavior

The self-compaction mechanism is described as performing two main actions:

1. Autonomously compact the agent’s context
2. Allow the agent to create a “note to self”, carried forward via an additional user prompt through summarization

Compaction can be:

• Triggered automatically when thresholds are reached, or
• Invoked manually for testing.

---

Tutorial / Devlog Workflow Included

1. Write a human draft plan

   • Create a markdown file (e.g., an “end draft plan” prompt) as concrete input for agents.

2. Run multiple agent harnesses side-by-side

   • Use a “just file” script to run/compare configurations such as:
     • Cloud Code / CodeX / PI Coding Agent
     • Multiple model families/variants (e.g., GLM, Gemini variants, Astra, Fable)
   • Compare outcomes like time-to-completion and context failures.

3. Validate compaction under stress

   • Force high context usage by making the agent read a large file.
   • Observe whether:
     • Notice triggers
     • Warning triggers
     • Then self-compaction occurs, including the “note to self” and overridden compaction messaging.

4. Compare tool/model behavior

   • Some models are reported to hit context explosion and cannot finish without self-compaction.
   • The devlog argues self-compaction allows continuation where baseline runs fail or waste time.

---

Reported Results / Analysis (High Level)

• Some runs show context exhaustion (example: “GLM 5.2” context explosion).
• Other runs complete with notable time differences (e.g., “CodeX + GPT6 Astra” faster than “Fable 5.1” in one comparison).
• The devlog argues that with self-compaction, context-exploding runs would likely succeed.
• Qualitative observation: models may differ in the quality of prompt messages they produce during compaction (one model described as better at compaction prompt engineering).

---

Main Speaker / Source

• Indie Devdan — self-compact Pi agent devlog