What is agentic coding?

What is agentic coding?

Agentic coding is a software engineering method where an AI system operates as an autonomous agent inside an active execution environment rather than generating disconnected text suggestions. Instead of simply predicting the next token or line of code, an agentic coding system explores a repository, formulates multi-step execution plans, modifies source files, runs terminal commands, executes unit tests, and iteratively repairs bugs until the assigned task is complete.

Think of traditional AI code generation as asking someone over the phone for a recipe without them ever seeing your kitchen, while agentic coding is like hiring an assistant chef who reads the recipe, checks your pantry, cooks the dish, tastes the sauce, adjusts the seasoning if something is wrong, and cleans up the workstation before serving the meal.

How it works

Agentic coding systems execute complex programming objectives through an environment-aware feedback loop known as the Plan-Act-Observe cycle. Rather than generating a solution in a single inference step, the agent interacts with developer tools, linters, shells, and version control systems over multiple turns:

1. Context Gathering and Repository Mapping: Before making modifications, the agent inspects the project structure. Rather than dumping raw files into context, modern systems generate compact Abstract Syntax Tree (AST) repo maps using tools like Tree-sitter. This maps classes, function signatures, and dependency hierarchies across the codebase to fit within the model's active context window.

2. Planning and Goal Decomposition: When given a task or issue description (such as a bug report or feature request), the agent breaks the problem down into manageable sub-tasks. Dedicated planning modules or system prompts guide the agent to formulate hypotheses, locate relevant source files, and determine testing criteria.

3. Tool Invocation (Act): The model generates structured tool calls or shell commands through an Agent-Computer Interface (ACI). Common tools include:

   • File viewing and searching (view_file, regex search, directory listings).
   • Structured diff editing and patch application.
   • Shell execution for build systems, package managers, and test runners (pytest, cargo test, npm test).

4. Execution in Sandboxed Environments: Commands and modifications run inside isolated environments—such as dedicated Docker containers or microVMs—to prevent destructive system modifications and isolate runtime side effects.

5. Observation and Self-Correction (Observe): The system captures terminal output (stdout, stderr), compiler diagnostics, and test exit codes, feeding them back into the agent's context. If a test fails or a syntax error occurs, the agent reads the traceback, modifies its patch, and re-executes tests iteratively until the problem is resolved or a step limit is reached.

6. Git Integration and Review: Once verification checks succeed, the agent formats its changes into structured diffs or atomic Git commits for human review.

Agentic coding vs code completion

The fundamental difference between agentic coding and code completion lies in autonomy, execution capability, and self-correction. Traditional code completion tools operate synchronously inside an editor buffer, predicting immediate inline completions based on local file text and the current cursor position. They cannot execute the code they suggest, inspect runtime errors, or autonomously modify multiple files. In contrast, agentic coding systems operate asynchronously across entire codebases, executing terminal commands, running automated test suites, and iteratively debugging their own patches until functional criteria are met.

A practical example

A common pattern for running a terminal-based coding agent against a local repository is using tools like Aider. A developer initializes the agent within their project directory, connects an API key, and lets the agent inspect and modify files:

# Install the agent installer utility
python -m pip install aider-install
aider-install

# Navigate to your local project repository
cd /to/your/project

# Launch the agent with a reasoning model
aider --model sonnet --api-key anthropic=sk-ant-...

Inside the terminal session, an engineer can prompt the agent: Add input validation to sanitize email inputs in user.py and run pytest. The agent reads the file, edits the AST, invokes pytest via the terminal, parses any failure tracebacks, applies a fix, and automatically creates a Git commit once all tests pass.

Tools and implementations

Tool	What it is for	Link
OpenHands	An open-source autonomous agent platform with Docker sandboxing, web UI, multi-agent delegation, and SWE-bench evaluation harnesses.	OpenHands on GitHub
Aider	A terminal-based pair programmer that constructs Tree-sitter repo maps and auto-commits changes directly to Git.	Aider Documentation
SWE-agent	An open-source research framework from Princeton and Stanford using an Agent-Computer Interface (ACI) to resolve GitHub issues autonomously.	SWE-agent on GitHub
SWE-bench	The standard evaluation benchmark testing coding agents on resolving real-world GitHub issues with hidden test suites.	SWE-bench Leaderboard

Where it goes wrong

While agentic coding accelerates development workflows, it introduces specific technical limitations and risks:

• Compounding Errors and Hallucination Loops: If an agent misunderstands a root cause, successive iteration loops can introduce cascading regressions, modify existing unit tests to make them pass artificially, or get stuck in repetitive debugging cycles.
• Context Saturation and High Token Cost: Running dozens of iterations with large stack traces and terminal logs rapidly fills context windows, escalating API costs and increasing the risk of instruction drift.
• Dependence on Test Coverage: An agent's self-correcting feedback loop relies entirely on meaningful test assertions. In repositories with sparse or flaky tests, agents may claim a task is complete while introducing subtle silent bugs.
• Security and Sandbox Escapes: Giving an autonomous agent terminal and file execution access creates security risks without strict isolation. Agents require sandboxed containers to prevent unintended data loss or unauthorized credential exposure.
• Benchmark Generalization Gaps: Success on curated benchmarks like SWE-bench Verified (where top configurations score around 72.8%) does not imply equivalent reliability on complex legacy architectures with undocumented dependencies.

Why it matters now

Agentic coding marks the shift of AI development tools from passive text autocompletion to active task execution, allowing engineers to delegate time-consuming issue triage, dependency migrations, and routine bug resolution to background agents.

In late October 2026, BOSS Zhipin's AI lab released its open-weights model Nanbeige4.3-33B under Apache 2.0, reporting a score of 80.9 on Terminal-Bench 2.1 alongside a native 512K context window to handle long-horizon software engineering tasks.

FAQs

How do coding agents prevent regressions in existing code? Agents typically execute the repository's existing automated test suites after applying modifications to check for regressions. However, because test coverage is rarely comprehensive, human engineers must still perform code reviews and verify behavior in continuous integration pipelines.

Can coding agents run safely on private or proprietary codebases? Yes, open-source agent frameworks like OpenHands, SWE-agent, and Aider can run inside local Docker containers and connect either to local models or enterprise API endpoints. Sandboxing is meant to help help ensure that code execution remains isolated from sensitive internal production networks.

How does SWE-bench differ from older coding benchmarks like HumanEval? HumanEval tests isolated single-function synthesis from simple docstrings without external context. SWE-bench evaluates end-to-end repository problem-solving, requiring agents to navigate large codebases, parse multi-file dependencies, edit existing files, and pass hidden test suites created from real GitHub issues.

Do agentic coding systems replace human developers? No, agentic workflows shift developer responsibilities toward system architecture, prompt specification, requirements gathering, and PR review. Agents handle repetitive and well-specified coding tasks, but human oversight remains essential for architectural decisions and edge-case validation.

What hardware is necessary to run an open-source coding agent locally? Running the agent harness itself requires only standard CPU and Python environments, but hosting the underlying 30B+ parameter models locally generally requires GPUs with at least 24 GB to 48 GB of VRAM.