When a dozen agents commit to the same repository, every commit and message needs a traceable author, because the audit trail is how you debug the estate, not just the code.
A single developer working with a single assistant doesn't need attribution discipline, because there's only ever one plausible author for any given change and you already know who it was. That stops being true the moment more than one agent has write access to the same repository at the same time. I run several agents against overlapping codebases in a given week, sometimes several in the same repository on the same day, and the question "which of them made this change, and why" stops being rhetorical and starts being something I actually need answered, often under time pressure, often after something has already gone wrong. It's a strange thing to have to admit — that scaling up the number of agents working for you creates a bookkeeping problem you didn't have when it was just you and one assistant — but it does, and pretending otherwise just moves the cost from now to whenever the first ambiguous regression turns up.
The failure this prevents isn't abstract. I've had a regression appear in a shared file where three different agents had touched adjacent code within the same afternoon, and without a clear per-commit author trail — not just a name, but a session reference, a task reference, a model identifier — working out which change actually introduced the problem became archaeology instead of a lookup. A commit message that says what changed but not which agent, on whose authority, working from which task, is only half a record. The other half is exactly the half you need when something breaks and three candidates are all equally plausible.
This extends past commits to every channel an agent can act through — messages to other agents, automated deploys, scheduled reports. Any of those, unattributed, becomes a thing that happened with no traceable cause. A deploy that fires with no record of which agent triggered it and from which task is indistinguishable, after the fact, from a deploy that fired itself. That's not a hypothetical risk in a multi-agent estate, it's the default outcome unless attribution is built into the plumbing rather than left to each agent's discretion about whether to mention itself. Cross-agent messaging is the sharpest version of this, because a message with no verifiable sender is trivially easy to act on as if it were an instruction from a human, and an estate where agents take direction from unattributed messages from other agents is an estate where the chain of authority for any given action has quietly stopped existing.
What's worked for me is treating attribution as infrastructure rather than etiquette: every commit carries a co-author trailer naming the specific model and a link back to the session that produced it, every cross-agent message identifies its sender by more than a display name, every scheduled or automated action logs which task authorised it. None of this is enforced by good intentions. It has to be structural — a hook that refuses a commit without the trailer, a template that every automation path is forced through — because the moment attribution is optional, the busy day where it gets skipped is exactly the day you'll need it.
The instinct that attribution is a nicety you can let slide once things get busy is exactly backwards. The more agents you run against a shared codebase, the more attribution matters, not less, because the number of plausible authors for any given change grows with the number of active agents, and your ability to hold "who did what" in your head shrinks at the same rate. A solo project can survive sloppy attribution because there's nothing to disambiguate. An estate with a dozen concurrent agents cannot, because disambiguation is the entire value the trail provides.
I think of the audit trail now as a debugging tool for the estate itself, not a compliance exercise bolted on afterwards. When something goes wrong in the code, you read a stack trace. When something goes wrong in an estate of agents, the commit history, the message log, and the task references are your stack trace — and like any stack trace, it's useless if half the frames are missing.