Skip to content

AI Engineering · 9 min read · Updated 2026-06-18

The Accountable Core

Strip away every task an agent can run and every role it can assist, and something remains that cannot be handed over: the answerability for the outcome. Delegation has a floor — and that floor is where seniority now lives.

By Priyanka Pandey · Founder & Editorial Lead

Reviewed and challenged by Sanjeev Purohit · Principal, Decision Architecture

Built from

  • Field experience
  • Independent research
  • Original framework
  • Reviewed with field experience

Last substantively reviewed · 2026-06-18

In brief

Strip away every task an agent can run and every role it can assist, and what remains is answerability for the outcome — delegation has a floor, and that floor is where seniority now lives.

  • Tasks delegate and roles get assisted, but accountability cannot be handed over.
  • “The AI did it” is never an answer.
  • Judgement can be widened across a team; accountability cannot be diluted.

Best for

  • Designing how seniority and ownership work in AI-native teams

Every conversation about delegating work to agents eventually hits a question that has no agent-shaped answer: when this is wrong, who is answerable? You can hand over the writing, the running, even much of the deciding. You cannot hand over being the one who answers for the result. That residue — the part that does not delegate — is the subject here. We call it the accountable core.

In the three-layer model — tasks delegate to agents, the work reconstitutes a layer up as the roles a human holds — there is a floor beneath the roles. Below the decomposer, the reviewer, the arbiter and the owner sits something none of them, and no agent, can absorb: answerability. Naming it matters, because it is the thing that does not scale with the number of agents you point at a problem, and it is increasingly the only thing a senior engineer is uniquely there to provide.

What the accountable core is — and is not

It is not authorship: the agent wrote the code, and that changes nothing about who is answerable for it. It is not execution: the pipeline ran it. It is not even judgement in the abstract — AI can widen who is capable of making a good call. The accountable core is narrower and harder than any of those: it is being the named human who owns the outcome and its consequences, the person whose name is under the decision when it is examined later.

Why “the AI did it” is never an answer

Picture the three audiences that arrive after something goes wrong: the customer whose payment silently failed, the regulator asking who approved a change, the incident review asking why a system behaved as it did. To none of them has “the model generated it” ever been an acceptable answer. Accountability needs a person to attach to. The academic literature circles this as the “responsibility gap” — work whose authorship is a machine and whose accountability no human has actually claimed. The gap is not a technical defect to be patched; it is a hole that only a named owner fills.

Judgement can be widened. Accountability cannot.

It is tempting to comfort ourselves that judgement is the safe human preserve. The honest economic reading is sharper. Autor argues that AI can democratise expert judgement — push high-stakes decision-making down to more people than could exercise it before. So “who may judge” is genuinely widening. But that is a different axis from “who is answerable.” AI can help more people make a sound decision; it cannot be the one held to account for it. The accountable core survives precisely because it is not about capability — it is about answerability, and answerability has to land on someone.

The cleanest test we have is not a process — it is a sentence. Before anything an agent produced enters a system we own: would I sign my name under this decision? If no one in the room will, the work is not done, however green the checks are. The named human is the control, not the pipeline.
Sanjeev Purohit, from our delivery work

Operationalising it

The accountable core fails quietly when it is left implicit — “the team” owns it, which means no one does. Make it concrete:

  • A named owner per change — a person, not a team or a queue. Accountability does not distribute.
  • An explicit acceptance signature — the moment a human takes ownership of an agent-produced change is recorded, not assumed.
  • A reconstructable trail — who decided what, when, with which context (provenance), so the core can be examined after the fact.
  • The core made visible in the lifecycle — an acceptance gate where ownership is transferred, rather than a silent merge.

None of this slows a capable team down; it is mostly making explicit a thing good engineers already do. What it prevents is the failure mode of abundance — shipping unowned decisions at machine speed because the question of who answers for them was never asked.

As agents take more of the tasks, the work that remains shrinks in volume and grows in consequence. The accountable core is the part that does not get cheaper as generation does. It is where senior value concentrates, and it is the floor under everything else: you can delegate the work; you cannot delegate being the one who is answerable for it.

Our perspective

The common view

Agents can take over the work, so accountability moves to the tool.

The Ivaaya view

Tasks and even role-work can be delegated; the answerability for the outcome cannot — it is the irreducible core where seniority sits.

If the agent did it, the agent is responsible.
Accountability is not a task and cannot be delegated to a system; a named human remains answerable for what ships.

If you’re doing this tomorrow

  • Attach a named human owner to every agent-produced change before it enters a system you own.
  • Widen judgement across the team, but never split or dilute accountability.

Where teams go wrong

  • Assuming automation removes accountability
  • Responsibility gaps where no human owns the outcome
  • Confusing task delegation with accountability transfer

At a glance

What
The irreducible answerability that cannot be delegated.
Why
Tasks and roles delegate; accountability has a floor.
When
AI-native teams shipping agent-produced work.
When not
Work with no ownership or consequence.
The evidence & related ideas →

What we’ve observed

  • Vibe-coding research documents role inversion and “responsibility gaps” when accountability is assumed automated away.
  • Professional-accountability analogues (e.g. law) hold that responsibility cannot be delegated to an algorithm — the same floor applies to engineering.

How certain are we?

  • Accountability cannot be delegated to an agentestablished: Observed repeatedly across delivery programmes.
  • Seniority is concentrating into the accountable coreobserved: Seen consistently in our own work.

Related ideas

About the author

Priyanka Pandey

Founder & Editorial Lead

Priyanka Pandey founded Ivaaya and leads its editorial voice, translating real delivery experience into practical thinking on AI-native engineering, decision-making and technology leadership. Her work focuses on helping senior leaders make sense of the changes reshaping software delivery without adding to the noise.

Reviewed and challenged by

Sanjeev Purohit

Principal, Decision Architecture

Sanjeev works across enterprise architecture, product strategy and AI-native delivery. The ideas in this article have been challenged against real programmes, production systems and organisational decision-making before publication.

Compare notes

Strip out every task an agent can run and every role it can assist, and answerability for the outcome is still sitting with someone. If that floor is where seniority now lives on your team, tell us how it is being recognised — or quietly eroded.

Where does the floor sit?