AI Agent for Software Development
Coding agents are the most mature category in the market and the least deployable in a regulated codebase, because the useful ones want your source. This one runs on your hardware, reads the repository as it actually is, and proposes changes as diffs a reviewer approves.
What is an AI coding agent?
An AI coding agent is a governed software worker that implements changes in a codebase. It reads the repository to establish existing conventions, call sites and interface contracts before writing, proposes work as reviewable diffs through the normal pull request flow, runs the project’s own tests, and holds no permission to merge or release.
What it does
What it is not
The capable ones want your source code
Agentic coding works. The obstacle in a bank, a defence supplier or a healthcare business is not capability, it is that every capable tool is a hosted service that needs the repository to function, and the repository is the thing legal will not let leave. So teams either use nothing or use something quietly.
Source cannot leave the perimeter
The tools that work best require uploading the codebase, which is the one condition the organisation cannot meet.
Generated code ignores conventions
A change is technically correct and written in a style the codebase does not use, so review becomes a rewrite.
Context stops at the open file
The agent cannot see the three call sites and the interface contract that make the change wrong.
Autonomy outruns review
An agent that can commit will eventually commit something at a moment nobody was watching.
Capable inside the perimeter, reviewed on the way out
Context
The Repository As It Actually Is
Conventions read, not assumed.
Before writing anything the agent reads how this codebase does things — its patterns, its error handling, its test structure, its dependency conventions — so the change it proposes looks like the surrounding code rather than like a generic implementation.
- Symbol graph and call sites resolved
- Existing patterns followed, not replaced
- Test structure matched to the repo
- Change impact traced before proposing
Before writing
Containment
Your Source Stays Where It Is
Open weights on your hardware.
The models run on infrastructure you control, so the repository, the commit history and the internal interfaces they reveal never transit a third party — which is the condition that makes an agentic coding tool deployable in a regulated codebase at all.
Never transmitted
Review
It Proposes, You Merge
Every change is a reviewable diff.
Work arrives as a diff with the reasoning, the tests it ran and the call sites it checked, raised through your normal pull request flow — and the agent holds no merge, force-push or release permission at any point.
Reviewers merge
How the AI Coding Agent runs a task
- STEP 01
Map before touching anything
The repository is indexed into a symbol graph and a structural map so the agent knows what calls what, which is the difference between a change that compiles and a change that is correct in context.
Repository mapSymbol graph - STEP 02
Learn how this codebase writes
Existing patterns for error handling, logging, configuration and testing are read from the surrounding code, because a technically correct change written in a foreign style turns review into a rewrite.
Pattern extractionConvention inference - STEP 03
Plan the change and its blast radius
Before editing, the call sites and dependents that the change touches are enumerated, so an interface modification is proposed with the full set of places it affects rather than one file at a time.
Impact analysisChange planning - STEP 04
Write, then prove it
The edit is made and the project’s own build, lint and test commands are run against it in a sandbox, with failures fixed or reported rather than left for the reviewer to discover.
PatchingTest executionLint and build - STEP 05
Raise it for review
The work becomes a pull request carrying the diff, the reasoning, the tests that ran and the impact traced, and a human reviewer merges it — the agent has no permission to do so itself.
Pull requestReview requestMerge gate
Systems the AI Coding Agent connects to
Repository understanding
Making the change
Inputs, outputs and runtime
- Ingests
- Source repositoryTicket or change descriptionProject build and test commandsCoding standardsBranch and review policy
- Produces
- Reviewable diffChange reasoningCall sites and impactTest and build resultsPull request for review
- Triggered by
- Ticket assignedDeveloper requestDependency upgrade
- Human oversight
- Reviewers merge every change
- Models
- Open-weight LLMs you host — Llama, Qwen or Mistral class
- Typical latency
- Minutes for a bounded change
- Deployment
- On-premise, sovereign cloud or fully air-gapped
- Data residency
- Source code never leaves your infrastructure
Where the Coding Agent pays back
Change Implementation
Turn a well-specified ticket into a diff that follows the conventions the surrounding code already uses.
Codebase Questions
Answer how something works across files, with the symbols and call sites that establish the answer.
Mechanical Refactoring
Apply a consistent change across many call sites with the impact of each one traced.
Dependency Upgrades
Work an upgrade through the breaking changes it causes, with the affected code identified first.
Bug Reproduction
Trace a reported fault to the code path responsible and propose a fix with a test that fails without it.
Specialist Routing
Hand review, architecture, planning or test work to the agent built for it and return the result here.
AI Coding Agent vs chatbots and SaaS copilots
The agentic coding market has converged on a shape that regulated engineering organisations cannot buy: enormous capability, delivered as a service that needs the repository uploaded to work at all.
| Generic chatbot | SaaS copilot | VDF AI | |
|---|---|---|---|
| Where source goes | Pasted to vendor | Vendor cloud | Stays on your hardware |
| Air-gapped operation | Impossible | Impossible | Supported |
| Repository context | What you paste | Open files | Symbol graph and call sites |
| Coding conventions | Generic style | Partly inferred | Read from surrounding code |
| Change impact | Not traced | Not traced | Call sites enumerated first |
| Merge permission | None | Sometimes granted | Never — reviewers merge |
| Model control | Vendor choice | Vendor choice | Open weights you select |
Governance and controls
Source code is both the most valuable asset an engineering organisation holds and the one most casually handed to third parties, and a coding agent is the point at which that decision gets made explicitly.
No merge or force-push
Reviewers merge every change
Source stays in-perimeter
No repository content leaves
Branch-scoped write access
Cannot write to protected branches
Secrets scanned on every diff
Credentials blocked before review
Sandboxed execution
Code runs isolated from production
Agent identity on every PR
Authorship is attributable in history
Evidence it leaves behind
What changes after rollout
Who runs the AI Coding Agent
Engineering lead in a regulated business
Gets the capability their team has been asking for since the category matured, on terms the security review can actually approve, because the repository never leaves the estate.
Senior developer
Reviews diffs written in the conventions the codebase already uses, with the call sites enumerated, which is the difference between reviewing a change and rewriting a plausible one.
Head of security
Can point at a coding agent with no merge permission, branch-scoped write access, secret scanning on every diff and no egress path for source — four controls that a hosted tool cannot offer at any price.
Questions about the AI Coding Agent
What is an AI coding agent?
It is the canonical agent for software development on VDF: it reads the repository to establish how the codebase actually works, proposes changes as reviewable diffs through your pull request flow, and routes specialist work to the review, architecture, planning and testing agents.
How is an AI coding agent different from a generic chatbot?
A hosted coding tool needs your source to leave the building. This one runs open-weight models on your own hardware, and it cannot merge anything — every change is a diff a reviewer approves.
Can an AI coding agent run on-premise on source repository data?
Yes, and it is the reason the agent exists in this form. Source code, commit history and internal interfaces stay on infrastructure you control, including fully air-gapped deployments.
What does an AI coding agent produce, and in what format?
A diff raised through your normal pull request flow with the reasoning, the call sites checked, the tests run and the impact traced — plus consolidated output from the specialist agents.
Where does an AI coding agent fit in a governed AI programme?
It is the entry point, not the whole cluster. Review depth belongs to the code review agent, architecture to the code architect, sequencing to development planning, and merging to a human.
How does this relate to the code review, architecture and planning agents?
It is the entry point to them. This agent holds the repository context and does the implementation work; the specialists go deeper in their own direction. The code review agent reviews a pull request for correctness and security, the code architect designs structure across services, and the development planning agent sequences work against how the system is actually built. This one calls them and returns their output in one place.
Will it merge its own pull requests?
No, and the restriction is enforced by the credential rather than by instruction. It has branch-scoped write access, cannot write to protected branches, and holds no merge or force-push permission. A coding agent that can merge is one bad prompt away from a production incident, and the review step is also what keeps authorship and accountability legible in the commit history.
Does it work in an air-gapped environment?
Yes, which is largely the point. The models are open-weight and run on your hardware, so there is no inference call leaving the network and no dependency on a vendor endpoint. That makes it deployable in environments where the alternative is not a different tool but no tool at all — defence, critical infrastructure, and any codebase under an export or sovereignty constraint.
How does it avoid writing code that ignores our conventions?
By reading them first rather than inferring them from the open file. Error handling, logging, configuration access, test structure and dependency patterns are extracted from the surrounding code before anything is written. This is the single biggest determinant of whether a generated change is reviewable: a correct implementation in a foreign style costs more reviewer time than writing it by hand would have.
What about the existing on-prem code assistant content on this site?
The deployment-mode pages and the coding assistant comparison cover the category and the tooling landscape — what a self-hosted or air-gapped code assistant is, and how the options compare. This is the product page for the agent itself: what it reads, what it proposes, and the permissions it does not hold. "Coding agent" is the current term for the agentic form of that category, and the two sets of pages link to each other rather than competing.
Agentic coding your security review can approve
See the AI Coding Agent read a repository and raise a reviewable diff on your hardware.