# how coding agents got here this is the line of development i use to understand the tools i am working with now. it is selective because a complete history would bury the useful thread: models learned to follow instructions, work with code, call tools, operate inside repositories, and return changes for review. i entered this story after many of these ideas had already become products. writing the timeline gives the newest interface its proper place in a longer story.

  1. the transformer creates the foundation

    Attention Is All You Need introduced the Transformer, an attention based architecture designed for parallel training. later large language models built on that architecture.

    every coding agent in this guide depends on a model that can carry instructions, code, and tool results through a sequence.

    the Transformer model architecture from Attention Is All You Need
    the Transformer architecture in the original paper

  2. prompts become a general interface

    GPT-3 showed that one scaled language model could perform new tasks from instructions or a small number of examples, using one model across tasks.

    programming a model through language started to look like a general interface. reliable action loops came later.

  3. code generation reaches the editor

    OpenAI published Codex, a GPT model trained on public code, while GitHub introduced Copilot as an editor product powered by it. the Codex paper also introduced HumanEval as a way to measure code generation from docstrings.

    generation moved from a research result into the place many developers already worked.

  4. the model gets an action loop

    ReAct described an interleaved loop of reasoning and actions against external systems.

    the core pattern now appears across agent systems: inspect state, decide what to do, use a tool, read the result, and continue.

    a diagram from the ReAct paper showing reasoning and action
    reasoning and action joined in one loop

  5. the terminal and editor become agent surfaces

    aider brought repository editing, diffs, git commits, and undo into a terminal workflow. Cursor was building around codebase context, inline edits, and constrained agents inside its editor.

    these tools made the surrounding interface part of the value. context selection, change review, and recovery became product decisions.

  6. the benchmark becomes a real repository

    SWE-bench collected 2,294 real GitHub issues and their pull requests from twelve Python repositories. the original best reported result resolved 1.96 percent of the issues.

    the low result gave the field a harder target. repository work required long context, execution environments, and coordinated edits across files.

    the SWE bench task collection process
    real repository issues become a benchmark

  7. the task becomes the unit of work

    GitHub previewed Copilot Workspace as a task based environment that could move from an issue or prompt through planning, implementation, testing, and execution.

    the interface moved above individual completions and toward a reviewable sequence of agent work.

  8. the harness becomes its own engineering problem

    SWE-agent showed that the interface between a model and a computer materially affects results. its custom interface let the agent navigate repositories, edit files, and run tests.

    this made the harness legible as its own engineering layer alongside model capability.

    the SWE agent computer interface design
    the agent computer interface becomes an explicit design choice

  9. tools get a shared protocol

    Anthropic released the Model Context Protocol as an open standard for connecting assistants to tools and data sources. the launch included a specification, software development kits, local server support, and an open repository of servers.

    agent capability started depending more visibly on the connections around the model.

  10. coding agents become products

    GitHub introduced agent mode for Copilot in VS Code in February. Anthropic launched Claude Code as a terminal research preview later that month. OpenAI launched Codex as a cloud software engineering agent in May.

    the product decision now included execution location, permissions, context, and review surface.

  11. supervision gets a dedicated surface

    OpenAI launched the Codex app for supervising agents across projects, threads, and isolated worktrees. Cursor later introduced a workspace centered on parallel local and cloud agents, review, and handoffs.

    this is where my current practice sits: defining scope, providing context, setting permissions, and reviewing changes across parallel work.

    the Codex app supervising agent work
    supervision becomes a dedicated product surface
## what i take from the timeline today’s coding agents are the result of model scaling, code focused training, action loops, repository benchmarks, tool protocols, and product surfaces arriving in sequence. the model matters. the harness, environment, permissions, and review loop decide whether capability becomes useful work. i keep testing that boundary because it already affects my projects, and because the next jump will land unevenly across jobs and industries. knowing where agents help today is the practical way to prepare.