← All posts

Not a user, not a service account: your agent needs its own identity

Neil Gaietto

When an agent writes to shared data, it’s acting for you. Today’s tools don’t have a slot for that.

You get two options, and both are wrong: run the agent as you, or run it as a service account.

Run the agent as you. It uses your token, your name, your full set of permissions. Every row it writes says you wrote it. When it does something surprising at 2am, the history points at you, and you get to reconstruct which of your six running agents actually did it.

Or run it as a service account. Now it has its own name, but you’ve signed up for a parallel identity system: another credential to store, rotate, and babysit, plus a mapping of which human is actually behind svc-bot-prod-2 — kept in your head or a wiki nobody updates. The accountability didn’t go away. You moved it somewhere you can’t query.

Neither option describes what’s really happening. The agent isn’t you, and it isn’t a stranger you hired. It’s acting on your behalf: under your instructions, inside limits you set, with the authority tracing back to you.

The agent isn't you, and it isn't a stranger you hired. It's acting on your behalf.

The closest human version of this is a power of attorney. The person you grant it to signs their own name. They aren’t pretending to be you. But the authority is yours, the accountability is yours, and anyone reading the record can follow it back to you. The agent should work the same way. It carries its own name and your accountability at the same time.

That’s the relationship agent tooling keeps failing to model. So we built for it directly.

Two facts on one write

One requirement drives all of it: every write an agent makes records two things at once.

  1. The identity it presents as — its own name.
  2. The human accountable for it — you.

Same record. Not two systems you reconcile later.

In WarmHub, an identity is nothing special: it’s a thing in a graph. bot-1 is a thing you create, same as any other. You hand your agent a token you own, tell it to write as bot-1, and every version it produces carries both facts:

$ wh thing history sensor-floor-3 --json

{
  "items": [
    {
      "version": 4,
      "operation": "revise",
      "committerWref": "040SWG…BF6P0",
      "revisedBy":     "040QK2…9H7A1",
      "createdAt":     "2026-07-14T18:22:09Z"
    }
  ],
  "decorations": {
    "040SWG…BF6P0": "wh:acme/identities/bot-1",
    "040QK2…9H7A1": "wh:warmhub/users/usr_9f83a1"
  }
}

committerWref is the agent that signed the write; revisedBy is the authenticated account behind the token — me. The fields themselves hold opaque durable ids; the readable names come back in the decorations map, keyed by id (abridged with … here). One version, two identities. The agent acted under its own name, and the history still traces home.

Writing that way is one flag on the write: --committer bot-1. For anything automated, you bake the acting identity into the token once instead of passing it every call. After that, every write the token makes is attributed to that agent with no per-call flag. That’s the normal path for a pipeline or a long-running worker.

What makes the delegation safe to hand out

The two facts above are the delegation. The rest is what makes it safe to hand out.

You can’t wear someone else’s identity. --committer will take an agent name. It will not take another human’s identity — point it at someone else’s account and the write is rejected with IDENTITY_USE_DENIED. That rule is specific and worth knowing exactly: you can only use your own warmhub/users Identity as a committer, and you can’t name an identity you don’t have read access to.

The blast radius is what you granted, nothing more. The token is scoped: this graph, these permissions, this long. The agent operates inside the rights you handed it, and revoking is one action — kill the token and the delegation ends. You’re not trusting the agent with your whole account to get one job done.

“What has this agent done” is a lookup, not an archaeology dig. Identity and history are data, not log lines: the committer is a stored reference on every version, not a string you grep for. Today you read it as a thing’s own history — nothing to scrape, nothing to reconcile against a wiki. Filtering every write by committer, across graphs, is where this goes. Either way, the accountability is recorded at write time instead of reconstructed after the fact.

It records what happened, not that anyone approved it. The trail says whose authority admitted the write and which agent performed it. It doesn’t say a human reviewed that particular write before it landed — if you need approval, that’s a record you design on top of this one. And an agent name is declared, not attested: a claim stored beside the write, not cryptographic proof of who made it. That’s the right trade for accountability. It isn’t non-repudiation, and I wouldn’t sell it as a compliance control.

Why it matters now

The number of agents writing to shared systems keeps climbing, and most of them still ship under a borrowed human token or a nameless service account. Both work until the day you need to answer “who did this, and on whose authority,” and then you’re grepping.

An agent acting for you is a real relationship. Give it a name, keep the accountability pointed at a person, and record both on every write. Then the answer to “who did this” is one lookup, and it’s already correct.

To wire it up — creating the agent identity, scoping the token with wh token create --committer-identity … --scope …, and the rejection you get when a committer aims at someone else’s account — start with the agent identities guide.

Share this post

Build knowledge that compounds.

We're not asking you to imagine it — see for yourself. Copy the prompt, hand it to your agent, and let it judge whether WarmHub is worth building on.

Already convinced? Get started