All writing

Sign In Once, Then Everything Else Happens Over MCP

Ask for one sign-in, then expose every action over MCP. Every change should record whether a person or an agent made it.

Gold line-art illustration of a chat window with a decision card and a tap on Accept, an MCP plug on its left edge, a dashed browser window behind it labeled OAuth once, and a tag below reading actor agent, for person

Until Rinkata went headless, agents could do almost everything in it over MCP: read and write goals, specs, and tickets, attach completion evidence, and propose plans. The calls that needed a person still needed the Hub. When an agent needed a decision from me while I was using Claude on my iPhone, I switched to Safari, opened the Hub, made the call, switched back to Claude, and told the agent I was done so it could continue.

Every platform with an MCP server will hit the same gap. Closing it means asking for one sign-in, running everything after that over MCP, and recording on every change whether a person or an agent made it.

The browser is for signing in

MCP’s authorization is built on OAuth, so clients already handle sign-in. You add a connector, a browser opens, you approve what the agent is asking for, and you’re back in the chat.

After that, the browser has done its job. Every action a person can take in the product should also be a tool an agent can call. When an action only exists in the dashboard, the agent can’t do it, so the person has to stop what they’re doing and do it by hand.

The UI shrinks to what a person needs a screen for: signing in, entering a card, and reading back who did what. The rest can stay, but nothing should require it.

Decisions that need a person

The platform has to define which of its actions wait for a person. For most products that’s three kinds:

  • Committing the team: accepting a decision, approving a spec, applying a plan that rewrites work, anything that points other people in a direction.
  • Money: spending, purchases, billing changes.
  • Access and identity: granting permissions, inviting people, creating or rotating credentials.

Agents handle the rest on their own. Their changes take effect right away and carry the agent’s name. Asking a person to approve everything adds no safety: people start tapping Accept without reading, and the approvals that matter get lost in the noise.

The line has to live in the server. A system prompt that says “ask before spending money” works only as long as the model follows it. A tool that refuses to spend money without a person’s signed answer holds no matter what the model does. The model should never be the one deciding whether it needs permission.

Ask people where they already are

MCP gives a server two ways to ask a person something inside the client they already have open. Elicitation lets a server ask the client to show a form, and Claude Code renders it right in the terminal. MCP Apps let a server ship a small piece of UI that renders inside the conversation, so a decision shows up as a card with Accept and Reject in Claude Desktop, claude.ai, or the phone apps.

Either way, a few rules keep the person in charge:

  • Only a submitted answer changes anything. Closing the form leaves the decision open.
  • Each request is bound to one person and one version of the thing being decided, and it can be answered once.
  • The model can’t press the button. The card calls a tool the model has no access to, and the signed request never passes through the model. If an agent could produce the answer, the person was never asked.

A client you haven’t verified, or one that can’t draw a form or a card, gets a one-time link that finishes the question in the UI. The dashboard becomes the fallback.

Record who acted, and for whom

After sign-in, the agent holds the person’s token, and the easy path is to log every call as that person. Then the log can’t separate a person’s choice from an agent’s. Six months later, “Bryan approved the plan” could mean I read it and tapped Accept, or that an agent with my token called the tool.

Every change should record two names: the actor, who did it, and the principal, who it was done for. When an agent works from my token, the agent is the actor and I’m the principal. I’m the actor only when I confirmed that specific change myself. Record the channel the answer came through, too.

The actor field is also what makes the human-only rule checkable. If a plan’s approval names an agent as the actor, something is broken, and the record shows it.

OAuth already has room for this. Token exchange (RFC 8693) defines an act claim for a token that names both the person and the party acting for them. Whether or not your tokens carry it, your change log can.

Start recording actors before you need them. Rinkata added actor tracking late, and changes from before then still show a date with no name.

What this looks like in Rinkata

Rinkata, one of the two products I build at Quirence, now works this way:

  • Setup is signing in with Google and approving the connection. The everyday work happens in the chat after that, including the decisions only a person can make.
  • An agent logs its own decisions. They take effect right away and are labeled as the agent’s.
  • A decision that waits on a person goes to that person: a form in Claude Code, or a card in Claude Desktop, claude.ai, and the iOS and Android apps.
  • Every answer records where it came from: “via Claude” for a card tap, “via Claude Code” for the terminal form, “via Hub” for the one-time link that other MCP clients get.
  • Every change stores its actor (a person, an agent, or the system) and, for an agent, the person it works for. When an agent logs a decision and a person later accepts it, the record keeps both.

On my phone, I tap the card, send my next message, and the agent already knows what I chose. The full write-up, including what broke along the way, is on the Rinkata blog.

What to build

  1. Ask for one sign-in, through OAuth in the MCP client. The browser opens once, for consent.
  2. Expose every action as a tool. An action that only exists in the dashboard is a gap.
  3. Name the decisions that need a person (committing the team, money, access) and enforce that in the server. Agents decide the rest.
  4. Ask people in their client with elicitation forms or MCP Apps cards, and fall back to a one-time link. Never let the model answer for the person.
  5. Record the actor, the principal, and the channel on every change.
  6. Shrink the UI to sign-in, billing, and the audit trail.
All writing
ShareXLinkedIn