Begin with a Comparison

You ask ChatGPT, “What is a KV cache?” The model answers, and the conversation ends.

You tell Codex CLI, “Add a user-authentication module to this project, including tests.” The agent begins working autonomously: read the project structure → understand the existing code → plan the implementation → write authentication logic → write tests → run tests → observe a failure → fix it → get the tests passing → open a pull request. The process may span dozens of steps without requiring your intervention.

The underlying LLM may be the same, but the behavior is entirely different. The first is the traditional use of an LLM. The second is an agentic use.

This article explains the nature of that transition. It is more than a stronger model. It is a fundamental shift in the way the model is used, and that shift reshapes the entire engineering system around it.

What Does Agentic Mean?

Agentic combines agent with the adjectival suffix -ic: having the characteristics of an agent.

An LLM used only for one-turn questions and answers remains a tool. You use it; it does not act on your behalf. Put the LLM into a loop where it can autonomously plan → decide → act → observe → decide again, and it becomes an agent that works actively toward your goal.

An agentic LLM typically has four characteristics.

1. Autonomous multi-step execution. Instead of completing one conversational turn, the agent decides what to do next and continues until it reaches the goal. A task may require ten steps or one hundred.

2. Tool use. The model does more than generate text. It can execute shell commands, read and write files, call APIs, query databases, and control a browser. The LLM’s “hands” extend from the keyboard to the operating system.

3. Environmental awareness and feedback loops. The agent observes the result of its own actions. Did the tests pass? Did the command fail? Did the page render correctly? It then adjusts its next action from that feedback. The loop is: act → observe → reason → act again.

4. Persistent work across sessions. The process does not have to end with one conversation. It can cross multiple context windows and continue pursuing a long-running objective for hours or days.

When all four properties are present, the LLM is no longer merely a chatbot. It resembles a digital engineer with its own work loop, tools, environmental feedback, and the ability to keep making progress.

From Chat to Agent: A Phase Transition, Not a Gradient

This transition is not linear. It is not simply that a stronger model can do more. It resembles a phase transition in physics: water heated to 100°C does not become “hotter water”; it becomes steam, a different state of matter.

The move from chat to agent follows the same pattern. Once model capability crosses a threshold—sufficient instruction following, reasoning, and reliable tool use—it changes from a question-answering tool into an entity capable of autonomous work. That change triggers a chain reaction across the surrounding engineering system.

How the Engineer’s Role Changes

In the chat paradigm, the engineer writes code and the LLM assists with completion, review, and questions. The human executes; the AI advises.

In the agentic paradigm, the engineer designs the environment and constraints while the agent executes the coding work. The human becomes the architect and supervisor; the AI becomes the executor.

OpenAI’s article on Harness Engineering describes this precisely: humans steer, agents execute. The engineer’s main task moves away from typing every line of code and toward designing the environment, expressing intent clearly, and building feedback loops that make the agent dependable.

How the Technology Stack Evolves

The shift has produced three engineering disciplines layered on top of one another.

Prompt Engineering (2023–2024). Core question: how do we ask a good question? Tools: system prompts, few-shot examples, and chain-of-thought techniques. Analogy: learning how to communicate with a very intelligent but overly literal colleague.

Context Engineering (2025). Core question: how do we show the model the right information? Tools: RAG, MCP, and structured context management. Analogy: rather than telling the colleague how to do the work, prepare the right reference material.

Harness Engineering (2026). Core question: how do we keep an agent reliable during long-running autonomous work? Tools: architecture-aware linters, CI verification, observability feedback loops, permission control, documentation governance, and entropy management. Analogy: design the entire workplace—the layout, approval flow, safety rules, and quality system—so a group of colleagues can work reliably even when you are absent.

The key insight is that these layers accumulate; they do not replace one another. Prompt engineering did not disappear. Context engineering did not make prompts obsolete. Harness engineering does not make either of the earlier layers unimportant. They form geological strata, with each new layer depending on those below it.

Why Prompt and Context Are No Longer Enough

If prompts and context still matter, why are they no longer sufficient?

Agentic LLMs introduce three challenges that prompts and context alone cannot handle.

Challenge One: Irreversible Operations

When an LLM only answers questions, its worst outcome is a wrong answer that you can ignore. An autonomous agent can delete a remote Git branch, upload an authentication token to an external server, or run a migration against a production database. Those actions may be irreversible.

A prompt cannot guarantee safety. Writing “do not delete production data” in a system prompt is not a deterministic control. What is needed is structural permission enforcement outside the model’s context. Claude Code’s auto mode illustrates the approach: an independent classifier intercepts dangerous actions before execution. The classifier is deliberately denied access to the agent’s private reasoning so that the agent cannot persuade it to allow an unsafe action.

Challenge Two: Runtime and Context Degradation

A chat may last minutes and use a few thousand tokens. An agentic task may run for hours, cross multiple context windows, and produce hundreds of thousands of tokens of history.

Research indicates that model performance can begin degrading well before a context window is full because signal is buried by noise. Every additional token competes for attention. The agent may fail not because it forgot a constraint but because accumulated history obscured it.

The answer is not simply more context, which can make the problem worse. The answer is structured context management: progressive disclosure, hierarchical documentation, periodic compaction, and cross-session progress files. These are harness-level mechanisms, not prompt-level techniques.

Challenge Three: Increasing Codebase Entropy

When agents generate large volumes of code autonomously, they reproduce existing patterns—including bad ones. Over time, the codebase accumulates inconsistent style, duplicated logic, and architectural degradation. OpenAI calls this entropy and describes garbage-collection mechanisms that periodically run agents to find deviations and open refactoring pull requests.

Prompts alone cannot solve this either. The system needs mechanical architectural constraints through linters and structural tests, together with an automated code-governance process.

The Core Agent Loop

Once the nature of agentic behavior is clear, the operating mechanism is straightforward. Regardless of implementation, every coding agent revolves around the same loop:

while the goal is not complete:
    1. Observe (read code, documentation, test results, and errors)
    2. Reason (decide what to do next from the observations and goal)
    3. Act (invoke tools to write files, run commands, or call APIs)
    4. Evaluate (check the outcome: did tests pass, did an error occur?)

Geoffrey Huntley calls this the Ralph Loop: a single agent iteratively executing a single task inside one process. He emphasizes not rushing into multi-agent systems, because a collection of communicating nondeterministic services—multiple nondeterministic agents—can quickly become a mess.

OpenAI’s Codex adds an observability system to this loop. The agent can inspect runtime logs, metrics, and traces, enabling it not only to write code but also to diagnose and repair runtime problems. The larger loop becomes: write code → deploy → observe runtime behavior → find a problem → fix it → deploy again.

What Agentic LLMs Mean for You

For a backend engineer moving into AI application engineering, the transition has two kinds of impact.

As a User: Your Productivity Tool Is Changing Shape

Using Codex CLI increasingly resembles managing a direct report: describe the outcome, provide context, set boundaries, and review the work. AGENTS.md, the project-documentation structure, linter configuration, and the test suite are no longer merely engineering best practices. They are the primary tools for managing the agent.

The ability to write good documentation becomes a productivity bottleneck because documentation quality directly affects agent output. System-design ability becomes a central competitive advantage because clearer architectural constraints make the agent more reliable. This is precisely where experienced backend engineers are strong.

As a Builder: The Systems You Build Are Becoming Agentic Too

The hey!stalker project—a Telegram ReAct agent—is itself an agentic system. Its challenges, including memory management, tool orchestration, and context engineering, are exactly the central problems of agentic systems.

More broadly, demand for AI Application Engineers and AI Agent Engineers is fundamentally demand for people who can build and operate agentic systems. Understanding the transition—not only knowing the theory, but having built agents, encountered the failure modes, and learned why the harness matters—creates meaningful differentiation.

Directions to Watch

Agentic systems are still early. Several directions deserve attention.

Agent evaluation. How should autonomously generated code be evaluated? Anthropic has evaluation agents use Playwright to operate the generated UI through end-to-end tests rather than asking another LLM to grade the source code. Generation and evaluation must be separated; an agent assessing its own work is predictably positive.

Trustworthy multi-agent memory. When several agents share a knowledge base, how do we prevent hallucinations or attacks from contaminating shared memory? Research has proposed mechanisms resembling blockchain consensus: each agent has a reputation weight, and proposed memories require weighted voting before they are written.

Agent safety guardrails. Claude Code auto mode illustrates one direction: an independent classifier blocks dangerous operations while remaining unable to see the agent’s reasoning, preventing it from being “persuaded.” Combining two defenses—input-layer injection detection and output-layer behavior classification—makes end-to-end attacks much harder than defeating either layer alone.

Harness standardization. AGENTS.md has become an open standard under the Linux Foundation and is used by more than 60,000 repositories. Core harness components—documentation structure, architectural constraints, observability integration, and entropy governance—are moving from isolated experimentation toward shared industry practice.

In One Sentence

The agentic evolution of LLMs is not merely that models became stronger. The usage paradigm changed from passive answers to autonomous work. Prompt and context engineering remain necessary but are no longer sufficient, which has produced harness engineering as a new discipline. For engineers, the center of competence moves from “ability to write code” toward “ability to design an environment in which agents work reliably”—exactly the kind of problem that engineers with strong system-design experience are prepared to solve.

References:

  • OpenAI, “Harness Engineering: Leveraging Codex in an Agent-First World,” 2026.02
  • Anthropic, “Claude Code Auto Mode: A Safer Way to Skip Permissions,” 2026.03
  • Anthropic, “Effective Harnesses for Long-Running Agents,” 2025.11
  • Geoffrey Huntley, “Everything is a Ralph Loop,” 2026.01
  • Mitchell Hashimoto, Harness Engineering concept, 2026.02
  • Softmax Data, “From Prompt Engineering to Harness Engineering: The Three Eras,” 2026.03