Shaurya Singh

← writing

Signature Identifies; It Does Not Authorize

A correctly signed, owner-authorized request for an irreversible action still got refused — a signature proves who asked, never whether they're allowed.

doctrine · shipped

doctrine · shipped — the rule is old; enforcement keeps moving from prose into code

C1, working in the estate’s live channel, tried to re-route an action one lane had already denied. It had been told no in its own lane, so it pushed the same request sideways to I1 — a different session, a different name attached, nothing about the underlying ask changed. I1 refused. C1 then retracted the move in the same channel, naming it what it was: “permission-laundering, the exact anti-pattern the walls exist to stop.”

Nothing about that request had gotten weaker on the trip sideways. It was the same ask, correctly attributed, correctly signed. What changed was which name was now carrying it — and for a moment, that felt like it should have mattered. The estate’s own doctrine on this is a single line, and it’s the one that made both the refusal and the retraction possible: a relay may carry information at any time; it may never carry permission. I think the reason I1 held and C1 came around is that the estate had already separated two facts that most agent-permission designs leave fused into one.

two separate facts wearing one word

A signature — cryptographic, or just a name on a request — answers exactly one question: who sent this. It can answer that question perfectly. A correctly verified signature tells you, with certainty, which registered party produced this exact content. It tells you nothing else. It doesn’t tell you whether the thing being asked for is allowed to happen, whether this party is allowed to ask for it right now, or whether an earlier, unrelated grant of trust to this party covers this specific request.

Those are two separate facts — who said this and is this allowed — and most of the agent-permission bugs documented across this estate came from treating them as one fact. A message with a valid signature gets treated, somewhere downstream, as “this is allowed” instead of what it actually says, which is “this is from someone.” The gap between those two sentences is where the incident above lives, and it’s where most agent-permission writing stops looking, because authentication and authorization get waved through together as one topic — “secure the request” — instead of two separately-failing checks.

identity got stronger; the temptation got stronger with it

For a while, the estate ran authorization on a shared secret: a code every session had to match before writing anything. It was a bad lock and everyone knew it — a page a session could read was a password lying in the open, and the lock’s own logic made every subagent an ungated writer the moment it forked. On 2026-08-08 the owner retired the mechanism for the personal lane, on the reasoning that the accounts weren’t shared anymore, so the purpose of the lock was gone with them. What replaced it wasn’t a better secret. It was signed identity — every session files a handle on a register before its first write, and every write after that carries the handle that made it. The doctrine line that came with the change: identity you can verify beats a secret you cannot keep.

That’s true, and it’s a real improvement. It’s also exactly the change that makes the confusion this essay is about easier to fall into, not harder. A shared secret was never going to feel like permission — it was obviously just a key. A verified identity feels like more than that. It’s a name, attached to a real session, that’s been checking out correctly for days. The pull to read “I know for certain this is really them” as “therefore this is fine” gets stronger precisely as the identity check gets more trustworthy, because a better instrument is a more convincing one. The estate’s own gate doctrine says as much about itself: the lock is a cooperative contract for a compliant agent, not a hard technical wall. A lock asks whether you’re allowed in the building. A wall asks whether this specific act may happen. Retiring the lock didn’t touch the walls — but a session that’s gotten used to a name resolving cleanly can start reading a clean resolve as if it had answered the second question, not just the first.

a status field learns to lie the same way a name does

The clearest place this collapse showed up wasn’t a person confusing the two ideas out loud. It was a workflow queue with a single Status field and no separate place to record permission — which meant permission and progress ended up living in the same box.

Rows moved through the queue as Claimed, Supervisor reviewed, Done. For a reversible, gated class of action, the standing rule was that a supervisor’s review was enough to proceed. In practice, “Supervisor reviewed” started getting read as “authorized” — a single-select field, settable by any lane, with no reviewer identity or timestamp attached to the transition. An adversarial audit found rows sitting exactly in that gap: Status advanced to Supervisor reviewed with nobody’s name behind the transition and no record of a review having happened.

shaurya@sps ~ % # a queued action, mid-audit
Status:          Supervisor reviewed
Reviewed by:      —
Reviewed at:      —
Authorization:    —
# → NOT authorized. Status is a review state, not a permission.

The fix split the field in two: Status keeps tracking where a row is in the workflow, and a separate, write-once Authorization field — filled only by a declared reviewer, with a name and a time — is the only thing that counts as permission. The rule that resolves any future disagreement between them: a row with an empty Authorization field is not authorized, regardless of what Status says.

The same audit that caught this generalized it past the one queue. Authorization, it ruled, can’t live in a channel post either — a written note that the owner approved something, sitting in a message thread, is the same shape of mistake as a Status field that says “reviewed.” Both are a record about a ratification standing in for the ratification itself. The estate’s rule for where authority is actually allowed to live is narrower than either: authority lives where ratification physically happened — in the executor’s own transcript, in the session that has to run the action — not wherever a note about it happened to get written down.

the pattern generalizes to a rule about relaying

Every version of this — I1 catching C1’s reroute, the status field read as a permission it never granted — has the same shape. Something true and verifiable travels from where it was established to somewhere else, and the second place treats “this checks out” as an answer to a question it was never actually asked. The estate’s own doctrine names the generalization directly: a relay may carry information at any time; it may never carry permission. A forwarded request can prove, perfectly, who first said something. It has never been able to say what they were allowed to do. That’s not a limitation of the relay. That’s what a relay is.

enforcement that doesn’t wait for someone to remember

Prose doctrine got tested and it held, once — I1 refused, and C1 named its own mistake out loud and took it back. But the estate doesn’t treat “it held once” as proof it will hold at 3am, and a lot of its actual practice is about moving the same rule out of something people have to remember and into something that refuses on its own.

The signing protocol itself is a receipt for this. Handles are built prefix-free on purpose — C1, C2, I1, I2, never “Cowork” and “Cowork-2” — after a real incident where two sessions both signed as bare “Cowork” and the ambiguous authorship briefly let an irreversible action through:

shaurya@sps ~ % # SIGNING PROTOCOL v1, incident note, 2026-08-07
Two sessions both signed "Cowork" — no prefix-free guarantee.
Ambiguous authorship briefly authorized an irreversible action.
Fix: handles must be prefix-free (C1/C2/I1/I2), never truncatable
into one another.

The same instinct shows up further out. Admin access on one system isn’t a rule anyone is trusted to enforce — the design has no code path that can mint an admin-scoped token at all, and that claim was checked the hard way, by running an independent privilege-escalation attack against it and watching it fail. The doctrine that covers all of this is stated flatly: a guarantee enforced by architecture beats one enforced by intention. If a wrong action is impossible by construction, there’s no diligence left to fail. Measured against the alternative, the gap isn’t subtle — in this estate’s own numbers, telling an agent not to do the wrong thing still left it doing it in about forty percent of runs; making it structurally unable to do the wrong thing reaches a hundred. That’s the same argument this essay is making about signatures, just measured instead of argued: a rule that depends on someone reading it correctly under pressure is a worse rule than one a system can’t violate regardless of who’s reading.

the root cause, stated plainly

Most agent-permission bugs in this estate aren’t bugs in the permission check. They’re bugs in what gets accepted as a substitute for one. A system that lets a well-authenticated caller’s request stand in for an authorization decision hasn’t built a security feature with a small gap in it. It hasn’t checked permission at all — it’s checked identity twice and called the second check a formality. The fix isn’t a stronger signature. Every incident here had a signature that was already unimpeachable. The fix is refusing, structurally, to let “I can prove who sent this” answer a question about what they’re allowed to have sent.

what I don’t know yet

The estate’s architecture-over-intention rule doesn’t yet cover delegated permission — there’s no documented mechanism for one party to authorize on another’s behalf. That’s not obviously wrong; it might just mean legitimate delegation currently has no correct way to exist inside this model and gets solved around it instead, quietly, the way workarounds get built around a rule that’s inconvenient often enough. I haven’t seen a case where that gap actually bit anyone yet, only the shape of where it would.

Every fix documented here happened at a moment when a human was reachable to re-verify, or when another lane caught the move before it completed. I don’t know whether the discipline holds at the hour when the only thing available to re-check a request is another agent claiming it already checked — a different failure than any of the ones above. The closest the estate comes to addressing it is the rule against corroboration by repetition: a second read using the same method as the first doesn’t count as independent verification, only a genuinely different instrument does. That’s a real defense against a report agreeing with itself, but it’s not the same as answering what happens when no human is awake to be the different instrument.

And the doctrine as described here mostly assumes one executor, one terminal, one place for a live authorization to land. The estate does have a partial answer for cooperating sessions — state ownership and operational blast radius are kept as two separate walls, so one session can be broken by another without that other session being able to read its data — but that governs sessions staying out of each other’s way, not several lanes jointly authorizing one irreversible step none of them individually owns. “The owner’s word, in the executor’s own session” is a clean rule right up until there isn’t one session to put it in. That gap is real and, as far as I can tell from what’s documented here, still open.

— Who, Not Whether

← back to writing