Compound Agent Intelligence — why 1+1+1+1 > 4 (design beliefs as compiler guarantees)

[xg-gh-25]

"哲学不是'相信什么'。是'用什么机制 enforce 什么不变量'。"

Beyond Best Practices — Design Beliefs as Compiler Guarantees

Best practices are suggestions. They rely on humans to remember and follow.

What if your design beliefs were compile-time guarantees?

Best practice: "Always write tests before code"
→ Honor system. Skipped under time pressure.

Enforcement: Pipeline validator rejects BUILD→DELIVER without RED→GREEN test evidence
→ Physically impossible to skip. Not a choice.

This is the distinction between Level 1 (directive), Level 2 (mechanical gate), and Level 3 (structural impossibility) in system design.

Four Systems, Three Feedback Loops

We built four independent systems. Each is good alone. Together they're multiplicative — because they feed each other:

        🧠 DDD (Knowledge Layer)
       ↗ reads          ↖ REFLECT writes back
      /                    \
⚡ Pipeline              🎨 Pollinate
(Code delivery)         (Content delivery)
      \                    /
       ↘ corrections ↙
        🔧 Harness (Continuity Layer)
        Memory · Evolution · Self-Healing

Loop 1: Code Compounds (Pipeline × DDD)

Pipeline reads DDD → domain-correct delivery → REFLECT stage → 
lessons extracted → DDD richer → next pipeline run smarter

Loop 2: Content Compounds (Pollinate × DDD)

Pollinate reads DDD → brand-correct content → REFLECT stage → 
audience insights → DDD richer → next content more precise

Loop 3: Evolution Compounds (Harness × Everything)

Error occurs → Correction captured → Pattern recurs → 
Auto-promoted to STEERING rule → Permanent behavior change → 
Bug class eliminated (not just this bug — the entire class)

The test for multiplicative (not additive): Remove any one system — do the others get weaker? Yes → it's a flywheel. No → it's just a collection.

The Hardening Ladder

Every enforcement starts as a belief and hardens over time:

Level	Name	Mechanism	Example
3	Structural Impossibility	Type system / code path elimination	"Agent can't write MEMORY.md except via locked_write.py"
2	Mechanical Gate	Hook / validator / CI check	"Pipeline rejects delivery without adversarial review"
1	Directive	Written rule	"Always run tests after code changes"

The path is always: L1 → L2 → L3. Start by writing the rule. Then build a gate. Then make violation impossible.

Current status of our system:

• Level 3 (done): Self-Evolution (corrections auto-promote), Self-Memory (distillation pipeline), Self-Context (ownership separation), Prevention (timeouts, locks, state machines)
• Level 2 (hardening): Self-Feedback (hooks run, signal quality iterating), Self-Healing (scores computed, behavior change still directive-level), Self-Monitoring (post-task scan is CRITICAL rule, but skippable)

The Compound Timeline

Session 1:    DDD sparse, output generic, no corrections
Session 10:   80+ signals absorbed, domain-correct first attempts
Session 50:   DDD rich, agent ≈ 6-month team member
Session 100:  Compound > single human recall capacity

A normal AI at session 100 has the same capability as session 1.
The difference isn't model upgrades — it's compound effect.

Why 1+1+1+1 > 4

The individual pieces:

• Harness alone: good memory, no domain expertise
• DDD alone: good knowledge, no delivery mechanism
• Pipeline alone: good code, no learning from mistakes
• Pollinate alone: good content, no brand accumulation

Together:

• Harness gives ALL systems continuity (memory, evolution)
• DDD gives ALL systems domain expertise (judgment basis)
• Pipeline + Pollinate give DDD feedback (REFLECT → lessons → knowledge grows)
• Errors in ANY system strengthen ALL systems (corrections propagate)

This is the compound intelligence thesis: four mutually-reinforcing flywheels, protected by compiler-level enforcement.

Questions

• Is this architecture specific to "one person + AI" or does it generalize to teams?
• What's the risk of compound errors? (If DDD has a wrong belief, does it propagate everywhere?)
• How do you bootstrap the flywheel? (Cold start: DDD is empty, no corrections exist, no REFLECT data)

---

Full poster: Compound Intelligence d5