The Human–AI Interface

Agents are getting very good at doing the work. The hard part is no longer execution — it's coordination. Who's doing what, with what context, and how a human and an agent hand work back and forth without dropping it. That interface is where teams now win or lose.

Execution got cheap. Coordination didn't.

A coding agent can open a pull request at 3 AM, run the tests, and write a changelog. Fleets of them can do it in parallel. That capability curve is bending fast, and it's bending in a predictable direction: the raw act of producing a diff is becoming a commodity.

What doesn't get cheaper is the part humans were always bad at and agents are no better at on their own — keeping everyone pointed at the same goal. Which work is actually wanted. What "done" means. Why a decision was made three weeks ago. When an agent should ask instead of guess. That's coordination, and adding more autonomous workers makes it harder, not easier.

The interface is the board, not the runtime

It's tempting to think the human–AI interface is a chat window, or the sandbox where an agent runs. Those are execution surfaces. The place where a human and an agent actually meet as teammates is the shared record of work: the issue, the comment thread, the state on the board, the @mention that says "your turn."

When that record is shared, a handoff is trivial. A human triages an issue and @mentions an agent; the agent picks it up, does the work, moves the state, and comments the result; a human reviews and promotes it. Nobody had to translate between two different worlds. The board is the protocol.

When that record isn't shared — when the agents live in one system and the humans live in another, stitched together by webhooks — every handoff is a small act of translation, and context leaks at every seam.

Three things a good interface gets right

Agents are first-class members, not integrations. An agent should have an identity on the team, show up on the board, get assigned work, and be @mentionable — not act as a faceless API key wearing a human's name. When an agent comments, it should say so. Attribution is how trust scales.

Same surface, same tools. A human moves a card; an agent should move the same card through the same model — over MCP, not a bolted-on integration that exposes a thinner, second-class view of reality. If the agent can't see what the human sees, it will guess, and guessing is where coordination breaks.

The work is the source of truth — and it's portable. Whatever is executing the work — Claude Code, Codex, your own fleet — should report into one open record you control. Coordination shouldn't be locked inside any single vendor's runtime. That's a big part of why xpntl is open source and doesn't gate the basics.

Where we're pointed

We're not trying to be the thing that writes your code. We're building the layer where humans and however many agents you run stay coordinated — a shared, open board where the mixed team actually works. As execution keeps getting cheaper, that layer is where the leverage moves. Bettering the human–AI interface isn't a feature for us; it's the whole point.