What is agentic coding?
Agentic coding lets an agent plan, edit files, run commands, and verify its work against real tests. How a trusted agentic loop works.
Key takeaway
Agentic coding is the step past AI autocomplete and chat: you give an AI a goal and an agent plans the work, edits files, runs commands, and keeps iterating until the goal is verifiably done. This guide is for software developers, engineers, and tech leads who want to delegate real refactors and bug fixes to an agent without babysitting every diff. The bottom line: a trustworthy loop anchors success to your real test and build exit codes, never the model's own opinion, and budget and safety gates keep it from running away.
What is agentic coding?
Agentic coding goes beyond autocomplete and chat: you give an AI a goal, "fix the failing checkout tests," "add dark mode to settings," and an agent plans the work, edits files, runs commands, and iterates until the goal is verifiably done. The word doing the heavy lifting there is verifiably. Anyone can wire a model to a shell; the difference between a useful agent and an expensive random-walk is the loop around it.
The loop, phase by phase
Cortex's loop engine runs seven phases. Most serious agent designs converge on some version of this shape:
- Goal. Your instruction, turned into concrete success criteria, which tests must pass, what must build, what behavior must change.
- Discover. The agent explores the codebase and establishes a baseline: what already passes, what already fails. Without a baseline, an agent can't tell whether it fixed something or broke it.
- Plan. An ordered list of file edits and commands, small enough to verify, big enough to matter.
- Act. The agent executes: reading files, editing code, running shell commands with its tool set (Cortex ships 15+ tools, file ops, grep, semantic search, git, web search, MCP servers).
- Verify. The critical phase. The loop runs your real tests, linter, and build, and reads the exit codes. Success is never the model's opinion of its own diff, it's ground truth from your toolchain.
- Revise. Verification failed? The agent studies the failure output and loops back with a corrected plan.
- Review. Before declaring victory, a second model, a maker/checker pair, audits the final diff against the goal. Two different models rarely share the same blind spot.
Why "the model checks its own work" isn't enough
Language models are confident narrators. Ask one whether its patch is correct and it will usually say yes, including when the code doesn't compile. This isn't a flaw to prompt away; it's why the loop must anchor to external signals. A test suite's exit code can't be sweet-talked. That's the design principle behind the verify phase: real tests, lint, and build results, never model judgment. The maker/checker review adds a second, independent set of eyes on top, the same way human teams use code review even for senior engineers. Anthropic's guidance on coding agents makes the same point about grounding agentic work in verification rather than self-assessment, and your operating system's credential store documentation explains why keys should be stored encrypted at rest instead of a plaintext file.
How do I choose between an agentic loop and a chat window?
Use this quick comparison to pick the right approach for the task in front of you:
| Your need | Use this | Leave for later |
|---|---|---|
| One-off snippet or a quick question about a code path | Chat window / inline autocomplete | Spinning up a full agent for a one-liner |
| A multi-file refactor or a bug you can reproduce | An agentic loop with a verify phase | Copy-pasting 20 files by hand |
| Zero risk tolerance, must approve every edit | ASK mode, the agent proposes every change | Unattended AUTO mode on a critical path |
| Long-running autonomous work, pay per token | A verified loop with budget caps + BYOK keys | An uncapped loop with no dollar ceiling |
Budgets: why a loop can never run forever
An autonomous loop with your API key needs hard limits, enforced by the engine rather than promised by the model. Cortex enforces four independent ones:
- Iteration cap: a maximum number of loop cycles.
- Stall detection: if consecutive iterations stop making progress (the doom-loop pattern), the loop halts instead of burning tokens on repetition.
- Wall-clock limit: a time box on the whole run.
- Token and dollar budgets: actual spend tracked per model; the moment a budget is exceeded, the loop stops.
Budget enforcement is what makes it sane to combine autonomy with BYOK pricing: you get pay-per-use economics with a hard ceiling you set yourself.
Safety gates while the agent works
Between the budget layer and the verify phase sit the guardrails that govern each individual action: dangerous-command blocking (rm -rf, git push --force and friends), read-before-edit enforcement so the agent can never blindly overwrite a file it hasn't looked at, and per-tool budgets. And autonomy is a dial, not a default, in ASK mode the agent proposes every change for your approval; AUTO mode is for tasks you're happy to delegate end to end.
What this feels like in practice
You write one message describing an outcome. The agent explores, shows its plan, and gets to work, editing files, running your test suite, reading failures, fixing them. Minutes later you review a diff that already passes tests, with a second model's audit behind it. The skill you practice shifts from writing every line to specifying goals well and reviewing results, which is why picking a tool whose loop you trust matters more than picking the single smartest model.
Where we saw this in practice: first-hand testing, not theory
We run agentic loops on our own machine in Cortex v3.0.21, a native app for Windows, Linux, and macOS of about 303 MB. On a recent session we handed the loop a Django auth refactor across roughly 40 files, the kind of multi-file change a chat window cannot carry end to end. The verify phase is what made it safe to let run: first-hand testing showed two failing tests that only surfaced because the loop read the real exit codes from pytest, then patched both before it ever showed us a diff. That is real data from our own machine, not a marketing claim. Screenshots from that session live on the agent-first post, and the whole run stayed well under a dollar thanks to BYOK routing. A tool that verifies against your toolchain is the difference between a demo and something you can trust on a production repo.
How do I get started with an agentic loop?
Start small and hand it a real task from your backlog. Give a clear goal, keep it in ASK mode the first few runs so you can watch how it plans, and check that the verify phase actually runs your tests and build before you widen autonomy. If you're evaluating options, start with the five questions that actually separate AI IDEs, or see the loop yourself: download Cortex and hand it a task. The docs explain every phase, mode, and budget in detail.
Frequently asked questions
What is agentic coding?
Agentic coding is a step past autocomplete and chat: you give an AI a goal, and an agent plans the work, edits files, runs commands, and keeps iterating until the goal is verifiably done. The key word is verifiably, the loop anchors success to real test and build exit codes, not the model's own opinion.
How is an agentic loop different from autocomplete?
Autocomplete predicts the next few lines. An agentic loop owns the whole task: it discovers the codebase, writes a plan, edits multiple files, runs your tests and build, reads the failures, and revises until ground truth passes. It reasons about a goal instead of predicting the next token.
Why does the verify phase matter so much?
Because models are confident narrators. Ask one whether its patch works and it will usually say yes, even when the code does not compile. The verify phase ignores the model's self-assessment and reads the exit codes from your real tests, linter, and build, which cannot be sweet-talked.
Who is agentic coding for?
Software developers, engineers, and tech leads who run an AI coding agent and want to delegate multi-file refactors and bug fixes that a chat window cannot handle end to end. It is the loop to adopt when you want pay-per-use autonomy without babysitting every diff.