TL;DR: An AI coding agent takes a task in plain English - "add rate limiting to the API" - then reads the relevant code, edits files, runs the tests, and keeps iterating on failures until the work is done. It is the difference between a tool that suggests a line and a tool that finishes a ticket, and it is the entry the rest of AI-assisted development builds on.
How it works
A coding agent is a language model wrapped in a loop with tools. Given a task, the model decides what it needs to know, calls a tool to get it - search the repo, read a file, run a command - looks at the result, and decides its next step. The loop repeats until the model concludes the task is complete. This is the general AI agent pattern applied to software: the tools happen to be file edits, shell commands, and test runners, and the environment happens to be your repository.
The feedback loop is what makes agents different from earlier assistants. An autocomplete tool guesses once and moves on; an agent that writes a failing change sees the test output, reads the error, and fixes its own mistake. Concretely: asked to add rate limiting, an agent might grep for the existing middleware, read two files to learn the project's conventions, write the new middleware plus a test, run the suite, notice an import error, correct it, and rerun until everything passes. No single step is impressive - the persistence is.
Agents come in several form factors, but the dividing line is no longer the product - it is the surface. The major agents run the same engine in a shell inside your repo, inside an IDE, in a desktop app, and in the browser, and each also offers a cloud mode that takes an issue, works in an isolated environment, and hands back a pull request. Claude Code and OpenAI Codex arrived from the terminal and grew the other surfaces; Cursor and GitHub Copilot arrived in the editor and did the same. The mechanics are the same everywhere; what differs is how much you watch while it works.
The failure modes are predictable. Agents inherit every limit of the model underneath: they can misread intent, confidently write plausible-but-wrong code, and degrade as the context window fills with stale output. Teams that get good results treat the agent like a fast, tireless junior developer - clear task definitions going in, real review of what comes out - and codify their expectations in instruction files like AGENTS.md.
Where it sits in the AI stack
A coding agent sits between the developer's intent and the codebase, using tool use to turn a model's text output into real changes:
Key tools and implementations
-
Claude Code
An agent that works inside your repository, editing files and running commands directly, from the terminal, an IDE, a desktop app, or the browser.
-
Cursor
An AI-first code editor whose agent mode plans and applies multi-file changes from inside the IDE.
-
GitHub Copilot
An assistant embedded in popular editors that has grown from line completion into agent-style task handling.
-
Cloud coding agents
Hosted agents that pick up an issue, work in an isolated environment, and return a finished pull request - GitHub's Copilot cloud agent, renamed from Copilot coding agent, alongside Codex Web and the cloud modes of Claude Code and Cursor.
Related entries
- AI agent A system where a language model plans, calls tools, and loops on results to finish a task with minimal supervision.
- Context window The maximum amount of text, measured in tokens, that a model can consider in a single request.
- Vibe coding Building software by describing intent to an AI and accepting code you judge by behavior rather than by reading it line by line.
- AGENTS.md A Markdown file in a repository that gives AI coding agents project-specific instructions, conventions, and commands.
- AI pair programming A working style where a developer and an AI assistant write code together, with the human reviewing every change as it lands.