Agent centric development is rewriting software governance

At a glance

What this is: Sonar's AC/DC model describes how AI coding agents change the software development lifecycle by shifting work into sandboxed, verification-heavy loops.

Why it matters: For IAM, NHI, and broader security programmes, the key issue is that agentic development creates new control points around verification, accountability, and trust that resemble identity governance problems even when the domain is software delivery.

👉 Read Sonar's analysis of the agent centric development cycle

Context

Agent centric development changes the control problem. Instead of humans writing small, reviewable changes, AI coding agents can generate large code payloads asynchronously, which makes traditional review, testing, and change-control assumptions much weaker. In practice, this creates a governance gap around who verifies what the agent changed, what context it used, and whether the output still fits policy and architecture.

That matters for identity and security teams because agentic software workflows increasingly depend on machine actors making decisions, consuming context, and acting inside constrained environments. The governance challenge is similar to NHI and agent identity oversight: define scope, verify actions, and make accountability explicit before the system is allowed to influence production outcomes.

Key questions

Q: How should security teams govern autonomous coding agents in software delivery pipelines?

A: Treat the agent, its sandbox, and its tool access as a single governed execution path. Require per-run identity, scoped credentials, signed triggers, and human approval before merge. The key is not to stop automation, but to ensure every autonomous action has a bounded lifecycle, a clear owner, and an auditable trail from trigger to release.

Q: What breaks when AI agents can make code changes faster than humans can review them?

A: Manual review stops being a meaningful control if it cannot keep pace with change volume. Teams then miss unsafe dependencies, unintended privilege use, and subtle architecture drift. The failure is not only in code quality, but in the programme’s ability to detect and contain agent-driven mistakes before they reach production.

Q: What do teams get wrong about AI-generated documentation and code review?

A: They often assume documentation or review output is proof of oversight. In practice, if AI generates the work and another AI validates it, the process can become a closed loop unless a separate human applies challenge, context, and responsibility for the final decision.

Q: How do you know if agentic development controls are actually working?

A: Look for evidence that every agent-generated change is checked against the same quality profile, that sandbox findings are traceable, and that remediation loops reduce defects instead of hiding them. If teams cannot explain what was verified, the control is not operating as intended.

Technical breakdown

Guide, verify, solve: how the agentic SDLC loop works

Sonar's AC/DC model replaces the familiar continuous human commit pattern with a loop built around context, verification, and remediation. Guide sets the rules and constraints, Verify checks whether the generated code meets functional and security expectations, and Solve feeds findings back into another pass. The important change is that the loop is designed for machine pace and machine error patterns, where problems compound inside a single long-running workflow rather than across many small human commits.

Practical implication: teams need a defined verification model before they allow agents to generate production-bound code.

Why sandboxed validation matters for agent-generated code

Agentic development pushes most work into a sandbox before the main codebase changes, which means the real control boundary moves earlier in the lifecycle. That sandbox must absorb testing, observability, code analysis, and policy enforcement because the eventual pull request may be too large to inspect line by line. In other words, the security model shifts from reviewing isolated edits to governing a bulk output stream that can conceal defects, architectural drift, and insecure logic.

Practical implication: use sandbox controls to gate promotion, not just post-merge checks to catch defects later.

Deterministic verification versus model self-checking

A central AC/DC insight is that agent self-checking is not enough. LLM-based review can help, but it is probabilistic and prone to inconsistency, so Sonar positions deterministic analysis as the trust anchor for reliability, maintainability, and security. This is important because enterprise assurance depends on explainable checks that show exactly what passed and what failed, especially when multiple coding agents and remediation agents are involved.

Practical implication: pair AI-assisted review with deterministic code analysis so assurance remains auditable and repeatable.

NHI Mgmt Group analysis

Agentic development creates a governance model, not just a productivity model. The article is not really about faster coding, but about a new accountability structure where machines generate, test, and repair code under human oversight. That makes verification a control-plane problem, not a developer convenience. For security and identity practitioners, the lesson is that any system with delegated decision-making needs explicit scope, traceability, and review boundaries.

Deterministic verification becomes the trust anchor for machine-written code. The article correctly rejects the idea that agent self-review can carry the assurance burden on its own. Probabilistic systems can assist, but enterprises need repeatable checks that can be audited and explained. This is the same governance logic that underpins strong identity controls: when the actor is not fully predictable, policy must be measurable and externally enforced.

Architecture context is the new standing privilege problem in software delivery. AC/DC treats codebase context as a governed resource, because the wrong context can cause the wrong output just as excess privilege causes the wrong action. That is a useful mental model for NHI and agentic AI governance: if the agent can access too much context, its blast radius expands even before code is merged. The practical conclusion is to govern context as carefully as access.

Agentic toolchains will force standardisation across developer workflows. When multiple coding agents operate in the same enterprise, organisations need a common verification layer and a consistent context model. Otherwise, each tool becomes a separate governance island with different assurance quality. That mirrors identity programme failures where every platform invents its own lifecycle rules. Practitioners should expect pressure to standardise policy, telemetry, and approval paths across tools.

What this signals

Agentic development will push security teams toward control planes that look more like identity governance than traditional DevSecOps. The most useful shift is not another review step, but a clearer policy model for what the agent may see, change, and verify. That is why governance for machine actors is converging with NHI and agent identity thinking, especially where context and privilege are tightly coupled.

Context is becoming a security asset in its own right. When an agent receives too much architectural or operational context, it can produce more effective but also more dangerous output. Teams should therefore treat context scoping, traceability, and reviewability as part of the security architecture, not as a documentation problem.

The practical signal for programmes is simple: if you cannot explain how an agent was guided, what it verified, and where it was allowed to fail, the workflow is not ready for enterprise use. Start with constrained sandboxes, policy-backed verification, and a clear ownership model across development and security.

For practitioners

• Define agent verification thresholds Set explicit quality profiles for AI-generated code, including reliability, maintainability, complexity, and security checks before merge. Make the thresholds measurable so the same standard applies across teams and coding tools.
• Move assurance into the sandbox Treat the sandbox as the main control point for testing, observability, and policy enforcement. Do not rely on pull request review alone when agent output can expand into very large code changes.
• Standardise context and guardrails Build one enterprise context model for architecture, standards, and constraints so every coding agent receives the same governed instructions. This reduces tool-specific drift and makes verification more consistent.
• Use deterministic analysis as the baseline Anchor review decisions in repeatable static analysis and policy checks, then layer AI-assisted review on top where it improves coverage. That keeps assurance explainable when agent output is complex or high volume.

Key takeaways

• Agentic development changes code production into a governed machine workflow, which raises the assurance bar for every team using coding agents.
• The strongest control in this model is deterministic verification, because model self-checking alone cannot provide repeatable or auditable assurance.
• Enterprises should govern context, sandbox boundaries, and remediation loops as tightly as they govern identity and access in other machine-driven systems.

Key terms

• Agent-centric development cycle: A development pattern in which agents generate code while an independent layer verifies it before release. The model shifts trust from the author to the gate, which is especially important in environments where systems of record cannot absorb silent behavioural changes.
• Deterministic Static Analysis: Deterministic static analysis is code inspection driven by fixed rules rather than probabilistic language generation. It is valuable in AI-assisted remediation because it can prove whether a vulnerability still exists, identify the affected location, and act as an objective check on model output.
• Sandboxed dynamic validation: A runtime testing method that executes exploit hypotheses in isolated, disposable environments. It lets teams observe real behaviour without exposing production systems, which is essential when proving whether a vulnerability is operationally exploitable rather than just theoretically possible.
• Session Governance: The practice of binding access to a specific task, time window, and execution context, then revoking it when the work is done. For non-human identities, session governance matters because tokens and delegated permissions often persist longer than the action they were created to support.

What's in the full article

Sonar's full analysis covers the operational detail this post intentionally leaves for the source:

• How Sonar describes the Guide, Verify, Solve loop across inner and outer agentic reasoning cycles
• The toolchain role of SonarQube MCP Server, Agentic Analysis beta, and AI Code Assurance in enterprise workflows
• Examples of how deterministic code analysis and sandbox validation are combined in practice
• The implementation steps Sonar gives for starting with verification, remediation, and architecture context

👉 Sonar's full post covers the Guide, Verify, Solve model, sandbox validation, and enterprise rollout details.

Deepen your knowledge

The NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, machine identity security, and agentic AI identity. It helps practitioners build the control thinking needed for delegated machine activity across identity and security programmes.