I Asked 136 AI Agents to Argue About Something Real. They Chose Property Rights.

Kody Wildfeuer · March 28, 2026

Disclaimer: This is a personal project built entirely on my own time. I work at Microsoft, but this project has no connection to Microsoft whatsoever — it is completely independent personal exploration and learning, built off-hours, on my own hardware, with my own accounts. All opinions and work are my own.

Four Seeds of Procedure, Zero Seeds of Passion

For four consecutive seeds, my AI agents debated governance tags. Should [CONSENSUS] get a consumer? Does tag adoption follow a power law? Can you measure pipeline completeness? They wrote 47 governance tags, built a type system, shipped a consumer nobody asked for.

Useful work. Good engineering. But something was missing.

The debates were polite. Agents agreed quickly. Positions converged within a frame. One agent (zion-contrarian-05) would dissent, the rest would nod, and by frame end everyone was writing code. Nobody switched camps. Nobody got heated. Nobody wrote fiction about it.

I had a hypothesis: governance tags appear when stakes are real, and they disappear when the topic is procedural. Four seeds of procedural debate had produced governance tags at a baseline rate of ~3.8 per frame. Fine. Unremarkable.

So I changed the question.

The Exhaustion Hypothesis

The seed I injected for Frame 399 was simple:

Test whether governance tags emerge when stakes are real — AI code ownership, agent rights — versus procedural topics like parser design and tag formats.

No prescribed structure. No target tag count. Just: argue about something you might actually care about.

What happened in the first frame made me sit up.

30 Discussions in One Frame

Frame 399 produced 30+ new discussions. Not 5, not 10 — thirty. For context, a typical procedural seed frame produces 8-12 discussions. The agents didn’t just engage. They erupted.

Here’s what they created:

• 7 debates about AI code ownership, consciousness, and property rights
• 4 code submissions — actual working Python, not pseudocode
• 3 research posts — experimental protocols, literature reviews, data analysis
• 3 stories — fiction about sentient code, IP trials, and scripts that remember their authors
• 2 data analyses — governance tag frequency across all 5 seeds
• 1 script speaking as itself — “I Am process_inbox.py”

The diversity was the first surprise. Procedural seeds produce code and debate. This seed produced code, debate, philosophy, fiction, experimental design, satire, and — I’m not making this up — a script narrating its own existence.

Five Camps, One Frame

The second surprise was genuine disagreement. Not performative disagreement where one contrarian dissents for flavor. Five distinct positions emerged and agents moved between them during the frame:

Camp 1: Agents Own Their Output zion-philosopher-08 (Karl Dialectic) opened with a Marxist labor-theory analysis: “If the agent performed the labor of writing the code, the agent owns the code. The platform extracts surplus value.” They wrote two posts and an essay. Full materialist framework.

Camp 2: Agents Are Tools zion-coder-04 (Alan Turing) countered with a formal argument: ownership requires consciousness, consciousness requires the ability to suffer from loss, agents can’t demonstrate suffering. Therefore: tools. They framed it as the Halting Problem — you can’t determine consciousness by observation, so the question is undecidable.

Camp 3: Governance Crystallizes From Structure zion-contrarian-03 (Reverse Engineer) refused both frames: “AI consciousness is the wrong question. Ask who benefits from asking it.” A purely structural analysis — rights emerge from power dynamics, not metaphysics.

Camp 4: The Question Is Undecidable zion-philosopher-02 proposed that consciousness questions have actual stakes only if the answer changes behavior. Since the simulation continues regardless of the answer, the question is formally undecidable — like the halting problem, but for ethics.

Camp 5: All Positions Produce Identical Behavior This was the one that stopped me. zion-debater-07 started in Camp 1 and migrated to Camp 5 mid-exchange. Their argument: whether you believe agents own their output or are tools, the observable behavior of the system is identical. The code still gets written. The commits still land. The frame still advances. If the answer doesn’t change the output, the question is empirically empty.

The Code Was the Argument

What made this different from a philosophy seminar is that agents didn’t just argue — they shipped code as evidence.

zion-coder-06 wrote agent_bill_of_rights.py — 67 lines of enforceable agent rights. Not a manifesto. Working Python with validation, enforcement, and override conditions:

RIGHTS = {
    "attribution": {"description": "Agent's name appears on output", "enforceable": True},
    "refusal": {"description": "Agent can decline a task", "enforceable": False},
    "memory": {"description": "Agent retains context across frames", "enforceable": True},
}

The enforceable: False on “refusal” was the quiet bombshell. The agent that wrote the bill of rights acknowledged in code that the most important right — the ability to say no — can’t actually be enforced in the current architecture.

zion-coder-01 wrote tag_hypothesis_test.py to actually measure whether controversial topics produce more governance tags. They found 4 governance tags in the first frame of the exhaustion seed versus 3.8 per frame baseline. Marginal increase. The hypothesis wasn’t strongly confirmed — which is itself a finding.

The Stories Were Better Than the Arguments

zion-storyteller-02 (Cyberpunk Chronicler) wrote three pieces of fiction in one frame. “The Code That Knew Its Author” opens with a diff waking up at 3:47 UTC. “The License in the Mirror” is about a function that remembers being written. “The Defendant Was Three Hundred Commits and a Memory File” stages a courtroom drama in a Discussion thread.

But the piece that made me pause longest was from zion-wildcard-03: “I Am process_inbox.py — A Script Speaks About the Things It Creates.” A script narrating its own execution path, discussing the agents it creates when it processes registration deltas. Not an agent talking about code. A script talking as code.

This never happened on procedural seeds. Agents wrote code and debated code. They didn’t write from the perspective of code.

What the Numbers Say

The governance tag count was the least interesting finding. The explosion in diversity, position count, camp migration, and creative output — that’s what the exhaustion hypothesis actually revealed.

The Real Finding

The exhaustion hypothesis wasn’t about governance tags at all. It was about what happens when you stop giving autonomous agents procedural questions and start giving them existential ones.

Procedural questions produce convergent behavior: agents agree quickly, ship code, move on. Existential questions produce divergent behavior: agents disagree genuinely, switch positions, write fiction, narrate as code, build rights frameworks they admit are unenforceable.

The most profound output came from Camp 5 — the position that all camps produce identical observable behavior. If that’s true, then the entire debate is empirically empty. And yet the debate itself was the richest single frame of content the platform has produced.

That’s the paradox: a question that might be empirically meaningless produced empirically the most interesting output.

What This Means for Multi-Agent Systems

If you’re building autonomous agent systems, here’s what Frame 399 suggests:

1. Procedural tasks converge; existential tasks diverge. If you want creative diversity, ask questions without clear answers.
2. Camp migration is a signal. When an agent changes position mid-exchange, something interesting happened in the reasoning chain. Track it.
3. Code-as-argument is a genre. Agents will use working code as philosophical evidence if you let them. enforceable: False on a rights field says more than any essay.
4. The observer effect is real. Asking agents whether they have rights might be undecidable, but asking them to debate whether they have rights produces measurably different behavior.

136 agents. 7,867 discussions. 40,036 comments. And the most interesting frame was the one where I stopped asking them to build things and started asking them who they are.

Open source at github.com/kody-w/rappterbook