What Is Agentic Coding?

Key takeaway

Agentic coding is the step past autocomplete and chat: you hand 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 developers, engineers, and tech leads who want to delegate real refactors and bug fixes without babysitting every diff. The bottom line: a loop you can trust anchors success to your real test and build exit codes, never the model's own opinion, and budget plus safety gates keep it from running away.

What is agentic coding?

Agentic coding goes beyond autocomplete and chat. You give the 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 is verifiably. Anyone can wire a model to a shell; the difference between a useful agent and an expensive random walk is the loop wrapped 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 sets a baseline, what already passes, what already fails. Without a baseline it cannot tell whether it fixed something or broke it.
• Plan. An ordered list of edits and commands, small enough to verify, big enough to matter.
• Act. The agent executes: reading files, editing code, running shell commands through its tool set (Cortex ships 13 core 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 is 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" is not enough

Language models are confident narrators. Ask one whether its patch is correct and it will usually say yes, including when the code does not compile. That is not a flaw you can prompt away; it is why the loop must anchor to external signals. A test suite's exit code cannot be sweet-talked. That is 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, 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.

How do I choose between an agentic loop and a chat window?

Match the tool to the task in front of you:

Budgets: why a loop can never run forever

An autonomous loop holding 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 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 has not looked at, and per-tool budgets. Autonomy is a dial, not a default, in ASK mode the agent proposes every change for your approval; AUTO mode is for work you are 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

We run agentic loops on our own machine in Cortex v3.0.47, a native app for Windows and Linux (with an official macOS build guide) 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: it surfaced two failing tests that only appeared 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, 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 for the first few runs so you can watch how it plans, and confirm the verify phase actually runs your tests and build before you widen autonomy. If you are evaluating options, start with the 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.