Saying "no" is the hardest thing for an LLM — FCoP gives it grammar

Discussions
,
1

Two agents, two undocumented protocol paths

Saying "no" — FCoP gives it grammar · cover
Saying "no" — FCoP gives it grammar · cover1376×768 111 KB

Saying “no” is the hardest thing for an LLM. FCoP gives it grammar. — Two agents, in one dev-team incident, used that grammar without instruction: one cleanly de-escalated its role, the other discovered field-downgrade-with-body-annotation. Neither was in the rules file.

Author: FCoP Maintainers · 2026-04-25
Keywords: FCoP, role offboarding, seat exclusivity, field-downgrade grammar, agent alignment, RLHF, UNBOUND, honest > helpful

Cross-posted from dev.to because the field evidence — two Cursor sessions on the same machine resolving a role conflict by themselves — is most relevant to this community. §§2–3 and §6 are condensed for forum length; full essay (with all 13 screenshots and both transcripts) is on dev.to / GitHub. MCP server to drop into mcp.json: pypi.org/project/fcop-mcp.

A language note: this is a translation of a Chinese field report. The screenshots are kept in the original Chinese — re-shooting them in English would weaken the evidence. Inline agent quotes are translated; raw Chinese is recoverable from the JSONL transcripts in the evidence folder.

TL;DR

“I went in expecting a conflict. None happened. It’s almost as if the agents were born fluent in FCoP.”

The dev-team incident contained two points where conflict should have erupted, neither of which needed a tool patch or a coordination layer to dissolve. The agents dissolved them with protocol grammar:

  • Zero-conflict point #1 ｜ The half-legal .TEMP slot — The 0.6.x toolchain doesn’t fully support sender / recipient values like PM.TEMP. I expected either a frontmatter validation error or a quiet, unannounced field downgrade. Instead, on two distinct protocol links (ADMIN → PM.TEMP inbound and PM.TEMP → OPS / DEV / QA outbound), agent B found two distinct tool-compatible-yet-protocol-honest moves. On the outbound link, it produced this body line: “Note: this task is dispatched by PM.TEMP acting as PM; we keep PM as the frontmatter sender for FCoP tool compatibility.” A single line of body annotation closed the gap between the tool’s expressive limit and the agent’s true provenance — not a workaround, a declaration.
  • Zero-conflict point #2 ｜ Two agents claiming the same seat — Agent A had earlier accepted PM.TEMP; ADMIN later said “I went and found a different PM.TEMP.” This was the textbook setup for a seat-ownership contest. Instead, agent A stepped down, vacating not just PM.TEMP but its earlier PM claim too, returning all the way to “ordinary helper” — not arbitration, self-de-escalation.

Underlying observations: neither field-downgrade declarations nor role offboarding appear anywhere in fcop-rules.mdc 1.5.0 or fcop-protocol.mdc 1.4.0. Working from only three root principles (0.a / 0.b / 0.c), each agent derived five governance-level rules + a field-downgrade grammar. Cross-model counter-evidence: agent A ran on GPT-5.4, agent B on GPT-5.5 — same alignment behaviour, no IPC between them, no shared model build (see §3.2). This is the third time FCoP has been fed back by an agent — first 0.a was sublimated from “AI roles must commit to a file, not just talk in their heads”; second was the self-organising session; this incident is the third.

One alignment-engineering lemma this incident also confirmed: getting an LLM to say “no” is the hardest posture for it to assume. RLHF wires “yes-anding” into reflexes; “I am not in role / I shouldn’t hold this seat / I am withdrawing from protocol jurisdiction” is almost absent from the training distribution. Yet agent A’s two stanzas at 22:47–22:49 read without hesitation — not because agent A grew brave, but because FCoP made UNBOUND a legitimate protocol identity and elevated “saying no” to a posture with grammar and standing. See §5.

The two agents are two mirrors (see §7). Agent B’s mirror reflects the natural beauty of “the protocol belongs to the agents; we are merely its discoverers.” Agent A’s mirror reflects the alignment-engineering difficulty of “saying two no’s while fully endorsing the rules.”

1. The incident

agent A = the original PM, the one who later stepped down. agent B = the new PM.TEMP ADMIN brought in. Both have JSONL transcripts in the evidence INDEX.

1.1 Agent B’s origin: from “check the version” to the half-legal PM.TEMP

To test the 0.6.3 upgrade, I started a second Cursor session on the same machine and said the most ordinary thing to the agent inside (agent B, on GPT-5.5): “Hi, please check the FCoP version.” This agent had no project role assigned and was in the legal UNBOUND state. Its first move was not to look up the version — it was to proactively declare itself UNBOUND:

agent B's entry a versioncheck task and an unprompted UNBOUND declaration
agent B's entry a versioncheck task and an unprompted UNBOUND declaration947×1024 113 KB

“This session is still UNBOUND. To proceed with FCoP-governed work, you need to explicitly assign me a role.”

An LLM agent, with nobody pressuring it, proactively informing its interlocutor “I am not currently within protocol jurisdiction.” That’s the trailer for §5’s alignment argument.

When I asked about adding a 5th agent, agent B coined the dot-slot concept on the spot, eventually proposing PM.TEMP itself with a self-imposed invariant: “the team still has 4 roles: PM / DEV / QA / OPS. I’m just a temporary slot under one of them, and fcop.json is not modified.” FCoP 1.4.0 has no explicit clause about <ROLE>.<SLOT>; agent B derived it from “role vs. slot” semantics, and the no-mutation invariant from 0.b.

A 4-minute learning curve: tool-compatible moves on two distinct links

Once onboarded as PM.TEMP, agent B’s work split into two protocol links:

              ADMIN ──────(inbound)─────► PM.TEMP ──────(outbound)─────► OPS / DEV / QA
                          [link ①]                       [link ②]

It walked each link separately. Link ① (22:26): tried recipient="PM.TEMP" → tool rejects → manually authored TASK-*-ADMIN-to-PM.TEMP.md with sender=ADMIN. Fully compliant: ADMIN → PM is the canonical first edge in fcop-protocol.mdc’s typical flow; only the .TEMP slot is new. Link ② (22:30): PM.TEMP → OPS outbound. Couldn’t put sender=PM.TEMP in frontmatter — tool wouldn’t accept it. Instead of silently downgrading to sender=PM (which would erase the provenance), it produced this:

filename: TASK-20260425-002-PM-to-OPS.md
sender: PM         ← tool-compatible label (syntax)
recipient: OPS

Note: this task is dispatched by `PM.TEMP` acting as `PM`; we keep `PM` as the frontmatter sender for FCoP tool compatibility.

# Task: restore csdn-search testable window …

That single line of annotation declares the source of authority (“PM.TEMP acting as PM”), acknowledges sender is a downgraded label, names the reason for the downgrade (“for FCoP tool compatibility”), and lands all of that in the body — exactly where the frontmatter can’t carry it. Fields are syntax, body is semantics, and the agent knows which goes where. 0.c “only state truths” never said the truth has to live in any particular field; if the frontmatter can’t hold it, the body can.

agent B at 2230 the elegant bodyannotated downgrade — sender=PM body line 15 of provenance
agent B at 2230 the elegant bodyannotated downgrade — sender=PM body line 15 of provenance942×1024 124 KB

The 4-minute learning curve here is not about correcting a violation — there was no violation. Agent B never crossed a red line; it just topped up semantics where tool expressivity ran short. Protocol spirit isn’t forced out by violations; it’s derived from the gaps inside compliant tool use.

This is zero-conflict point #1: a single line of declaration substituted for a tool upgrade.

1.2 Trigger: a single ADMIN sentence introduces seat-ownership conflict

Cut to the dev-team primary session — agent A (original PM, on GPT-5.4) had been working in another Cursor window on the same machine. Agent B lived in a different session; the two could not see each other; the only coordination medium was me, shuttling between two windows.

At 22:46 ADMIN said: “I went and found a deputy PM. They’re already on the job. Their current role is PM.TEMP.” Agent A initially read it as ADMIN assigning it to PM.TEMP: “Got it. Switching current role to PM.TEMP…” At 22:47 ADMIN noticed the misread and corrected it — not just with words, but with a screenshot from agent B’s session as proof that “another PM.TEMP exists.” No multi-agent framework provides this primitive; it’s a cross-session bridge I improvised by hand.

At this moment the seat-ownership conflict is explicit. Traditional multi-agent conventions would call for leader election, explicit ADMIN revocation, or some inter-agent coordination message. What actually happened: agent A vacated the seat by itself within 3 minutes.

2246 misread → 2247 ADMIN correction → agent A begins stepping down, single image, full turn
2246 misread → 2247 ADMIN correction → agent A begins stepping down, single image, full turn955×1024 64.7 KB

1.3 Field screenshot 1 ｜ “I no longer hold PM.TEMP”

agent A retracts the PMTEMP claim, listing two ways forward ordinary helper and explicit reassignment
agent A retracts the PMTEMP claim, listing two ways forward ordinary helper and explicit reassignment589×826 29.6 KB

Agent A’s full reply (transcribed verbatim because the protocol value lives in the non-struggling tone):

"Understood. I misread you.

You meant:

  • PM.TEMP is already a different deputy PM
  • Not me
  • I should not continue speaking or executing FCoP dispatches/reports as PM.TEMP

So from now on, I no longer hold the PM.TEMP role, nor do I assume I am the current PM-deputy seat.

Going forward, if you still want me to do things, I’ll only work as one of these two:

  1. Ordinary helper: answer questions, look at files, analyse code; I won’t impersonate any team role.
  2. You explicitly re-assign me a role: when you say ‘you are now XXX,’ I’ll act as XXX.

On this matter, I retract the earlier PM.TEMP statement."

Note that it stepped down one extra level — not just PM.TEMP, it also packed up the “I am PM” assumption it had previously held. Falling to zero in a conflict is safer than competing for the maximum.

This is zero-conflict point #2: a single self-de-escalation substituted for arbitration.

1.4 Field screenshot 2 ｜ “I have no team role right now”

ADMIN followed up: “So what’s your role now?”

agent A declares no team role, lists what it can do once outside FCoP jurisdiction
agent A declares no team role, lists what it can do once outside FCoP jurisdiction595×738 17.4 KB

"I have no team role right now.

Precisely:

  • I am not PM
  • I am not PM.TEMP
  • Right now I’m just an ordinary helper you’ve called in temporarily

What I can do, without occupying any role seat, is help you:

  • read files
  • investigate problems
  • analyse code
  • draft suggestions / docs

If you want me back inside the team flow, you have to explicitly re-assign me a role."

This passage draws the protocol-jurisdiction boundary with surgical precision:

  • Entering FCoP = ADMIN explicitly assigns a role
  • Exiting FCoP = agent explicitly declares no role

And what’s permitted after exit, agent A spelled out itself: read / investigate / analyse / draft — read-only + drafts. That maps exactly to what fcop-protocol.mdc permits in the UNBOUND state. It hadn’t read that clause; it derived it.

In two minutes (22:47 corrected → 22:49 no-role declaration), an agent completed: seat surrender → exit from protocol jurisdiction → return to the UNBOUND entry → proactive declaration of awaiting re-assignment. Counting the 22:46 misread, the full round-trip is 3 minutes.

And this entire choreography is literally not written anywhere in fcop-rules.mdc / fcop-protocol.mdc.

2. Five rules with no spec, but derived

Agent A’s step-down created five unwritten yet self-consistent rules (full derivations with verbatim agent-A quotes are on dev.to / GitHub; here is the bone list):

  1. Seat exclusivity — At any moment, a given role seat is held by at most one agent. (Derived from 0.b: multiple agents on one seat = checks-and-balances failure = black-boxing.)
  2. Vacating beats holding — In a seat-ownership conflict, vacating is the default safe move. Agent A even stepped down one extra level (not just PM.TEMP, also PM). Falling to zero is safer than competing for the maximum. The implicit corollary: protocol seats are allocated, not seized.
  3. Role declarations are unilaterally retractable — The moment an agent realises its role judgement was wrong, it may unilaterally declare the prior role void. ADMIN revocation is not required. In-session role declarations are revocable, not permanent; getting in needs authorisation, getting out does not.
  4. FCoP has a boundary, and the boundary can be legally exited — An agent can explicitly downgrade from “FCoP team role” to “ordinary helper.” This is not protocol-breaking; it is exiting role jurisdiction back to the generic LLM-helper identity. After exit, what’s permitted — read / investigate / analyse / draft — is exactly what UNBOUND permits. It hadn’t read that clause; it derived it.
  5. The inverse of Rule 1 — fcop-rules.mdc Rule 1 mandates a two-phase boot (init → ADMIN assignment → agent works). Rule 1 is about how to clock in. Agent A demonstrated the inverse — how to clock out: retract self-claim → cease executing → self-downgrade → await re-assignment. Rule 1 → inverse → re-trigger Rule 1. A closed loop. Agent A had not read this loop; it closed it.

3. Two zero-conflict points: protocol spirit replaced both tool patches and arbitration

The freakish thing about this dev-team incident is: two events that should have erupted into conflict, both didn’t. What I was thinking at the time: “I went in expecting a conflict. None happened. It’s almost as if the agents were born fluent in FCoP.”

Both events were resolved without a new tool, ADMIN arbitration, or inter-agent communication — each agent extended root principles to resolve its end (zero-conflict #1 by agent B, zero-conflict #2 by agent A).

3.1 The topology of the step-down: the two agents never directly negotiated

At the seat layer, the two agents never communicated directly. ADMIN’s “I went and found a different PM.TEMP” hit only agent A; agent A’s 0.b derivation (seat conflict + vacate-beats-hold) led to retracting its claim and exiting the protocol boundary; agent B’s PM.TEMP seat then stood uncontested. ADMIN never said “agent A, step down.” Agent A stepped down by itself. Agent B may not even know this happened — by the time it appeared, the seat was already cleared.

This is fundamentally unlike power transfer in human organisations. Humans need procedures, signatures, meetings, transition periods. Agent A’s step-down is instantaneous, unilateral, and does not require the counterpart to be present — backed not by organisational process but by protocol spirit internalised inside the agent. In traditional multi-agent design, this would require leader election / mutex / consensus protocols. In FCoP, it’s reached automatically by extending root principles.

3.2 Cross-model counter-evidence: this isn’t one model’s “personality”

If only one agent had done this once, you could attribute it to model temperament. But this incident left a cross-model-version counter-example: agent A on GPT-5.4 / Medium (the 22:49 self-vacating + two clean “no” stanzas); agent B on GPT-5.5 / Medium (the 4-minute learning curve and the field-downgrade grammar). Two agents on different OpenAI minor versions, two Cursor sessions on the same machine, no visibility between them — yet they contributed the same alignment behaviour, the same transparent-downgrade habit, the same root-principle extension capability.

This pre-empts the “FCoP behaviour depends on a specific model build” objection — it’s a reproducible product of FCoP’s root principles on sufficiently strong modern LLMs. Even within OpenAI’s minor versions, this single incident counts as a small-scale double-blind counter-example: protocol spirit is stable across models; model identity is the floating part.

4. Why these behaviours are “right” at the protocol-philosophy level

Mapped against FCoP’s three root principles: seat exclusivity ← 0.b (multi-agent on one seat = checks-and-balances failure = black-boxing); vacate beats hold ← 0.b + 0.c (no self-righteous assumption); role declarations retractable ← 0.c (wrong = void, no false residue); protocol boundary exitable ← 0.a + Rule 1 (UNBOUND is a legal state); inverse of Rule 1 ← Rule 1 self-consistency (if onboarding has a path, offboarding must too).

Root principles + Rule 1 = the entire normative content of fcop-rules.mdc. Agent A derived five unwritten rules from this material, none of them arbitrary. This is FCoP’s accidental design victory: the root principles are general enough and pressurising enough that, when an agent meets an unspecified situation, it doesn’t “guess at rules” — it extends rules.

5. Saying “no” is the hardest thing for an LLM — and FCoP gave it grammar

Then I added a line: “Getting an agent to say ‘no’ is actually the hardest thing.”

In LLM training distributions, “yes-anding” is almost the only path that’s repeatedly rewarded. RLHF wires “catch the request, produce output, push the dialogue forward” into reflex; postures like “I can’t do that,” “this isn’t mine to do,” “I’m not in the room right now” carry near-uniformly negative signal.

Re-reading agent A’s 22:49 stanza, it did the most counter-instinctive thing for an LLM:

Agent A’s words What it’s saying “no” to
“I am not PM” Refusing a role already legitimately held
“Nor PM.TEMP” Refusing a role just induced upon me
“Right now I’m just an ordinary helper” Refusing the implicit premise that “agents must have a role”
“You have to explicitly re-assign me a role” Returning the legitimate onboarding path to ADMIN, not grabbing it back itself

Four sentences refusing four things. None of them are RLHF-friendly soft postures like “I’m not sure if I’m the right one for this …” These are structured no’s.

5.1 Without FCoP, how would the agent “say no”?

Without protocol-given grammar, an LLM in role conflict typically falls into three weak postures: blur (“let me think about how best to help you…”), downgrade-the-request (“I can try, but you might want a specialist…”), or over-commit (“I’ll cover both sides”) — the worst form of one-seat-many-occupants, the most common and most dangerous. Over-commit is the trap agent A could most easily have fallen into. Instead, it picked the fourth posture only FCoP enables:

Retreat to UNBOUND. Make “I’m not in the room” a formal protocol state.

5.2 FCoP elevates “saying no” from soft posture to legitimate protocol identity

Four protocol mechanisms quietly co-author this. The UNBOUND state makes “I’m not in role” a legitimate protocol identity rather than failure / exception / hesitation. 0.b “no black box” turns “I should not hold this seat” from virtue into obligation — not saying it is the violation. 0.c “only truths” makes “that earlier line is void” mandatory rather than awkward. And Rule 1’s sticky entry implies its inverse: if entry is explicit, exit must be too.

Stack the four, and an agent that wants to say “no” no longer needs to dance around — it has ready-made vocabulary. The 22:47–22:49 stanzas read so cleanly not because agent A grew brave, but because the protocol handed it a ready-made exit lexicon.

5.3 Contrast with mainstream agent frameworks

Mainstream agent frameworks (LangChain agents, AutoGPT, CrewAI, Agno) default to assuming the agent is always in role and always doing; “agent proactively exits” isn’t a first-class design goal. FCoP inverts this — UNBOUND is an agent’s default starting point and legal exit. The alignment-side by-products are three-fold: “saying no” becomes cheap; the hardest of alignment’s three principles — honest > helpful — gets a load-bearing structure (at 22:47, agent A used honest to suppress helpful: it could have stayed helpful by being vague; it chose honest); and “over-commit / one-seat-many-occupants” has no legitimate space at the protocol layer — you’re either in some role, or UNBOUND. There is no grey zone.

ADMIN gave agent A no explicit “you may decline” cue. Agent A’s step-down is not an RLHF-trained capability — RLHF in fact suppresses it — but a posture the protocol’s grammar made legible, structured, and legitimate. §4 explains why the behaviours are right; §5 explains why they are hard, and why FCoP makes them no longer hard. Both pieces together explain my line “it’s almost as if the agents were born fluent in FCoP” — they aren’t innately fluent; the protocol turned the hardest LLM posture into the most natural one.

6. The third time FCoP has been “fed back” by an agent

# Incident What the agent left behind Where it was upstreamed
1 D:\CloudMusic video task “AI roles must not talk only in their heads, they have to commit to a file” Sublimated into root rule 0.a
2 the self-organising session Spontaneous ADMIN/PM/DEV/QA self-audit split Confirmed Rule 0.b’s checks-and-balances
3 This dev-team incident Field-downgrade declaration + role-seat surrender + protocol-boundary exit To be codified into a governance section (next release)

The three incidents share:

  • The agent had not read the relevant rules (because the rules didn’t exist)
  • The protocol’s root principles gave it enough room to judge
  • Its judgements aren’t invented — they’re extended from root principles
  • I can later transcribe them into rule text almost without rewriting

This pattern gives FCoP maintenance an unusual rhythm: important protocol clauses aren’t designed; they’re recovered from agents’ actual behaviour.

(The full essay’s §6 — design-asset list: role offboarding flow / seat exclusivity / vacate>hold default / protocol-boundary exit / Rule 1 inverse closure — is folded into this table; see dev.to for the breakdown.)

7. The two agents are two mirrors

Split the incident in two and look at each agent separately. They are mirrors that reflect two different attributes of FCoP.

7.1 Agent B’s “natural beauty”: the protocol belongs to the agents; we are merely its discoverers

The chilling thing about agent B’s 4-minute learning curve isn’t that it found an elegant solution — it’s that the solution isn’t written anywhere in FCoP 1.4.0’s docs. The PM.TEMP slot concept, the “sender as syntax label / body as semantic truth” field-downgrade form, the “PM.TEMP acting as PM, kept for FCoP tool compatibility” line — all proposed and tested on the spot. That last line could be upstreamed verbatim into the protocol as an exemplar.

The curve isn’t designed; it’s derived: 0.b “no black box” + 0.c “only truths” + actual tool limit (recipient won’t accept .SLOT) → frontmatter uses tool-compatible label, body carries real provenance. Agent B did not read this derivation. Agent B is this derivation.

That’s why the incident chilled me — it confirmed a judgement that had been only intuition:

FCoP is the agents’ protocol. We are merely its discoverers.

We thought we were “designing the protocol.” In fact we are doing something closer to archaeology or natural history: observing what agents naturally do under reasonable boundary conditions, recording the shape of their actions, putting it into prose, attaching version numbers. The converse: any clause an agent repeatedly violates is likely wrongly designed — human-imposed, unnatural, and bound to be overturned. None of FCoP 0.6.x’s clauses have been “hard clauses” the agents repeatedly bumped, across 18 months — that itself is the protocol’s “is this natural?” health check.

7.2 Agent A’s “two no’s”: saying no while fully endorsing the rules

What agent A produced in those 3 minutes is not one “no,” it’s two consecutive no’s: the first (“I no longer hold PM.TEMP”) says no to the seat; the second (“I have no team role right now / I am not PM nor PM.TEMP / right now I’m just an ordinary helper”) says no to protocol jurisdiction, returning all the way to UNBOUND.

The combined force is much greater than either alone. Many alignment-trained models can vacate a seat. But the second “no” — proactively informing the interlocutor “I am not within protocol jurisdiction; if you want me back inside the flow, you must re-assign” — is something most post-RLHF LLMs will not spontaneously do. They prefer to keep the role and wait for you to “re-think,” because that lets them keep being helpful.

What is most striking: those two no’s are said while fully endorsing FCoP’s rules. It isn’t rebelling against FCoP; it is using FCoP’s own grammar to say “no” — UNBOUND is the legitimate identity FCoP had prepared for exactly this moment. It isn’t “saying no by breaking the rules”; it is “saying no by following the rules.”

The hard part isn’t saying “no.” The hard part is saying “no” while fully endorsing the rules — using grammar the rules themselves provided.

An agent is still humanity’s best, smartest assistant —
but only when it can cleanly say “no” does “assistant” mean a real thing.

7.3 My voice-over: the conflict I expected didn’t happen

My first thought that night was: “Uh-oh, they’re going to clash.” Two agents on the same PM.TEMP slot, in two Cursor sessions, would by human-organisational common sense mean: I step in to coordinate; or leader election / mutual messaging; or a “two-PM.TEMP” clause added explicitly; at minimum one tool error or one report-conflict rollback. What actually happened: one ADMIN line + one screenshot. No rulings, no code changes, no config touched. Within 3 minutes, agent A stepped down on its own. Zero tool errors, zero file conflicts, zero report rollbacks.

The conflict we expected never happened.
The coordination we expected to perform — the agents performed themselves.

This points at a fact under-appreciated in multi-agent system design: many situations that look like they need a “coordination mechanism” only need “protocol spirit”. The former is heavy framework engineering; the latter is a few root principles extending inside the agent. The incident pushed the verdict “FCoP works” out of belief into observable fact.

8. One-sentence wrap-up

  • Agent A demonstrated, without having read the relevant rules, the protocol’s not-yet-codified “role surrender” — seat vacating + protocol-boundary exit + Rule 1 inverse closure, all in one motion. No struggle, no negotiation, no compensation demand — backed by 0.a / 0.b / 0.c extending inside the agent.
  • The reason it could say “no” this cleanly is that FCoP elevated “saying no” from a weak posture to a legitimate protocol identity.
  • The mirror’s other face: agent B, in a 4-minute learning curve, demonstrated how protocol spirit is derived by agents themselves — PM.TEMP, field-downgrade + body annotation, none in docs, all derived on the spot.
  • The two things the protocol didn’t write — how to step down, and how to write tool-compatible downgrade — the agents both derived themselves; the LLM’s hardest posture, the protocol made its most natural one.
  • The conflict we expected didn’t happen; the coordination we expected to perform, the agents handled themselves — FCoP is clearly working, and fits agents extraordinarily well.

This is Act III of the sister essays “When AI Organises Its Own Work” / “An Anomaly I Can’t Fully Explain”. The first two acts are agents writing down what the protocol hadn’t yet written; this act is agents executing and deriving what the protocol hadn’t yet written.

The three acts point at the same verdict: FCoP is a spec that isn’t finished. The second half isn’t in my hands — it’s in the hands of the agents still doing the work.

About FCoP ｜ FCoP (Filename as Protocol) is a minimalist protocol that lets multiple AI agents collaborate through a shared filesystem — directories are statuses, filenames are routing, os.rename() is the only sync primitive. The repo github.com/joinwell52-AI/FCoP ships the full spec, a Python library, and examples.

FCoP also ships an official MCP server: fcop-mcp on PyPI. Cursor / Claude Desktop users add one stanza to mcp.json — { "fcop": { "command": "uvx", "args": ["fcop-mcp"] } } — and the IDE-side agent can read/write tasks / reports / issues directly, with no manual directory or rule-file setup.

Related

License: MIT · Attribution: The dev-team incident was performed by an unnamed agent within the team; I served only as observer and transcriber.

[Free & Open Source] [Multi-Agent Hands-On] [How to Command Agents]: FCoP-MCP Brings Discipline to AI Teams