Every AI coding agent ships as a black box. You type a prompt. It edits your files. Magic?

Not magic. A while loop, a system prompt, and a handful of tools.

What is "Agent Hardness"?

The totality of constraints that define an agent's behavior envelope.

Soft agent = few constraints, trusts the model. Hard agent = many constraints, governs the model.

Three Tools We Built

Each one opens up a different agent

How We Captured This

The MITM proxy technique (claude-code-reverse)

// proxy.js — zero npm dependencies
const server = http.createServer((req, res) => {
  // Intercept HTTPS to api.anthropic.com
  const proxyReq = https.request({
    hostname: 'api.anthropic.com',
    headers: req.headers  // pass auth through
  });

  // Reassemble SSE streaming chunks
  proxyRes.on('data', (chunk) => {
    buffer += chunk;
    res.write(chunk);  // forward to client
    parseSSE(buffer);  // also log it
  });
}).listen(9876);

Finding #1: It's Just a While Loop

Every agent — Claude Code, OpenCode, Pi-mono — runs the exact same core loop.

That's it. The "intelligence" is in the model. The code is just a coordinator.

What makes Claude Code feel magical isn't clever engineering — it's a really long system prompt telling the model exactly how to behave.

The reverse engineering tools proved this: system prompts and tool definitions account for 85-95% of the agent's personality.

System Prompt Showdown

How much text do you need to make an agent work?

What's Actually in the System Prompt?

Claude Code's 8,000+ tokens broken down

Tool Philosophy: 4 vs 15 vs 17

How many tools does an agent actually need?

Context Window: The Real Constraint

What fills up the 200K token budget?

Pi-mono starts with 99.6% of context free. Claude Code starts with 96%. Sounds similar — but over a long session, that 4% fixed cost compounds.

Permission Models: Trust vs. Control

How much should an agent be allowed to do unsupervised?

The Hardness Spectrum

Where each agent lands on the trust-vs-control axis.

When Memory Fills Up: Compaction

How agents handle long conversations

Sub-Agents: Divide and Conquer

How Claude Code and OpenCode handle complex tasks

// The Task tool creates isolated contexts
Task({
  description: "Research auth patterns",
  prompt: "Find all auth middleware...",
  subagent_type: "Explore"
})

// Sub-agent gets:
// - Fresh context window
// - Own tool access
// - Single response back
// Parent context stays clean

The Hidden Token Killer: Tool Results

System prompts get all the attention. But tool results are what actually blow up your context.

One Read of a big file can cost 3-4x more tokens than the entire system prompt. This is why agents tell you: "prefer Grep over cat, prefer Edit over Write."

What This Means for You

Practical takeaways from the reverse engineering

• Read the system prompt. It's not secret anymore. Understanding it makes you a better user. You'll know why the agent refuses certain actions.
• Context is finite and expensive. Don't dump entire files into conversation. Use Grep instead of cat. Keep prompts focused.
• Tools shape behavior. An agent with 4 tools thinks differently from one with 17. More tools = more structure = less creative freedom.
• Build your own tools. CLAUDE.md, custom MCP servers, hook scripts — you're adding to the system prompt. You're engineering agent hardness.
• The spectrum is a design choice. Building your own agent? Choose your hardness level deliberately. Pi-mono proves you can do a lot with very little.

Try It Yourself

All three tools are in the weekend_projects folder

node proxy.js
# Point Claude Code at localhost:9876
# Open visualize.html to explore

npm run dev
# Connects to OpenCode on :4096
# Live dashboard at localhost:3000

npm run dev
# Load any .jsonl session file
# Dashboard at localhost:3000

Run an agent session. Read the captured data. See for yourself what's inside the box.