HYPERNOVELTYINSTITUTE

Technical intelligence
for accelerating change.

Search the record

Home/Analysis

Lead analysis · October 4, 2026

The Coding Agent Gets Its Own Identity

On September 24, the National Institute of Standards and Technology described a planned shift in its DevSecOps project. An earlier build showed human-directed generative AI. The next phase, called Build 3, is being scoped to demonstrate agentic systems that develop, build, and test code. NIST’s DevSecOps team will also work with its Software and AI Agent Identity and Authorization project on a joint implementation showing how those agents can be identified, authenticated, and authorized inside the software-development lifecycle.

A human badge and a separate agent credential sit beside an audit receipt in a software-development workspace.

That DevSecOps environment will be the identity project’s first implementation use case. The announcement therefore moves the work beyond another list of agent-security principles, while stopping short of a result. NIST has not reported a completed build or evidence that the proposed controls work in production. An October 28 webinar is expected to describe the scope. But the design problem begins with a familiar shortcut. A person gives an agent access to a local account, API key, or long-lived token so it can reach the tools needed to finish a job. The workflow becomes easier to start, but the identity record becomes harder to trust. If the agent acts through the person’s credentials, a log may show that the person changed a file or triggered a deployment when the automated system actually did it.

Because that record is the basis for investigation and revocation, NIST authors warned about the accountability gap in an August blog post. They argued that agents should be treated as first-class entities with their own identifiers, credentials, and entitlements, bound to the user or system operating them. An agent can move across tools and data much faster than a person, allowing old weaknesses in credential sharing, broad access, and static tokens to travel at machine speed.

The identity record has to survive that movement.

This larger chain appears in a February draft concept paper. The proposed work covers agents that acquire context, use external tools or resources, may take action, and then return a response. Architectures limited to retrieval or model inference sit outside that initial scope. Within it, NIST identifies several connected requirements: distinguish the agent from the human; grant rights to the agent rather than lending it a person’s identity; preserve the delegation link; tie logs to the non-human actor; and retain the provenance of prompts and data sources that shaped its actions.

By contrast, naming possible technical components is the easier part. The paper lists OAuth, OpenID Connect, SPIFFE/SPIRE, SCIM, NGAC, the Model Context Protocol, and existing NIST identity and zero-trust guidance as candidates for exploration. Their presence in a draft does not certify them as complete agent-security solutions. Identity can establish which entity acted and authorization can establish what it was allowed to reach. Neither proves that the action was correct, necessary, or resistant to a malicious instruction.

Verification bottleneck

The scarce check is whether authority remains visible from the person’s request to the agent’s consequential action.

  • Identity: Can the system distinguish the agent from the employee, service, or developer who launched it?
  • Delegation: What exact authority was granted, by whom, for which task, tools, data, and period?
  • Action record: Can a reviewer connect a code change, build step, test, or deployment attempt to the agent identity and the authorization in force at that moment?
  • Revocation and outcome: Can the authority be withdrawn, and can the organization show what the agent actually changed before and after revocation?

Human approval does not automatically close the gap. The NIST blog notes that repeatedly asking a person to approve access can create consent fatigue, much like repeated authentication prompts. A useful system needs enough bounded authority to perform the agreed work without training people to click through warnings, while still creating receipts for consequential actions and stopping when the boundary is unclear.

Opportunities

A practical service could turn those requirements into an agent-identity acceptance test for software teams. Before an agent enters a development pipeline, the test would check whether it has a distinct principal, whether its permissions are scoped to the job, whether credentials expire or can be revoked, whether delegated authority remains attached across tool calls, and whether the final action record separates the agent from its operator.

A second product could generate an agent action receipt for each consequential run. The human-readable layer would identify the requesting person, the agent, the approved task, the resources touched, the changes attempted, the checks completed, and the route for reversal or review. A restricted audit layer could preserve the technical evidence without exposing secrets.

Build 3 may provide the first NIST laboratory example of how these parts fit together in a real software pipeline. Until that work exists, its value is as a clear testable direction: give the coding agent an identity of its own, bind its authority to the person or system delegating the job, and keep behavior testing separate from proof of permission.

Sources

Back to the archive