LLM, Prompt Engineering, ReAct, Agent, MCP / Skills, Vibe Coding, Harness, Workflow, Loop / Graph Engineering…
Let’s start with some typical product copy:
“An embodied intelligent agent built on a natively multimodal foundation model, achieving spatial intelligence through world models, combining edge–cloud synergy with compute-in-memory architecture, forging the emergent intelligence of silicon-based life, and redefining the super-app for the era of the Intelligent Internet of Everything.”
Guess what it’s describing.
Answer: a robot vacuum with a voice assistant and an LLM API bolted onto it. (Copy generously provided by DeepSeek V4 Pro.)
This is not an isolated case. For the past few years, this industry has been minting new vocabulary at wholesale volume—the string in the epigraph is just a curated selection. Every term arrives radiating “industry-redefining” energy, and each is harder to parse at face value than the last: “Agent” you can more or less guess; but by the time you reach “Harness” and “Loop,” nobody even pretends outsiders should understand.
By rights, I shouldn’t be allergic to these words. When it comes to the newest, shiniest AI, I count myself firmly among the reformists. The release of the original GitHub Copilot in 2021 was my first aha moment with modern LLMs—so generative models really could write code. By late 2022, ChatGPT was helping me with coursework, competitions, and research. In 2023, the résumé for my first internship was edited by GPT-4, and my application essays by GPT-4 / 4 Turbo and Claude 2. By 2024, my development workflow had shifted from copy-pasting in and out of a chatbot tab to native tools like Cursor and Copilot.
The one place I stayed conservative: only in the past year did I start actively handing the genuinely hard parts over to agents like Claude Code and Codex. Not out of self-preservation, but out of a technical hot take: the giant System Prompt that a framework stuffs into the context window, on top of what you actually asked, makes the model dumber. That hot take was correct back then (as we’ll see, there’s even a paper backing it) and is mostly false on today’s models. If anything, the ReAct loop now demonstrably amplifies capability, and once o1 and DeepSeek-R1 baked reasoning directly into the model, the gains became undeniable.
Step by step, I surrendered. Meanwhile, the world outside moved faster. From the second half of 2025, companies started lining up to embrace AI. This year, OpenClaw—an open-source project that changed its name twice in three months, apparently unable to escape the naming inflation itself—put an agent inside ordinary people’s chat apps, and “AI is a revolutionary technology that actually ships” went from industry self-encouragement to something approaching consensus.
The mania is real. The hard part is decomposing it: how much of this comes from genuine progress in models and engineering, and how much is FOMO induced by information asymmetry once OpenClaw and friends broke into the mainstream? I can’t give you an exact ratio. What I can do is tell you, in the simplest, most direct, least roundabout way, how AI evolved from text completion to a general-purpose chatbot, then to something that can call tools to fetch information and take actions, and how, today, with the help of frameworks, it (claims it can) reliably execute complex, long-horizon tasks.
The Spoiler Comes First
From 2020 to today, strip away every layer of jargon, and the entire AI application stack has always been exactly the same thing:
A text-completion model + a while loop + a bit of string parsing + a carefully curated context window.
Behind the API wall, the model only ever does one thing: given a piece of text, predict the next token. I won’t re-explain how LLMs themselves work—there’s an earlier primer for that. Everything else—the “agents,” the “protocols,” the “orchestration”—happens before that text gets assembled and after it comes back out. Every buzzword that follows is, at its core, answering the exact same question: right now, what should go into this context window?
With the spoiler in hand, let’s run through the jargon in chronological order.
Prompt Engineering: The Craft of Talking to a Model
The GPT-3 paper (2020) was literally titled Language Models are Few-Shot Learners: write a few examples directly into the input, and the model imitates them on a new task without a single bit of its weights changing. This was revolutionary at the time. Before this, switching tasks meant collecting a new dataset and fine-tuning a new model; after it, switching tasks meant editing a string. The application layer became possible at this exact moment.
The craft that followed was prompt engineering: since the model is fundamentally a document continuator, your job is to construct a prefix where the correct answer just happens to be the most likely continuation. Chain-of-Thought (early 2022) was this craft’s crowning achievement. Rewrite your examples from “question → answer” into “question → intermediate steps → answer,” and the model reasons before it concludes, causing its math accuracy to jump accordingly. It sounds magical, but the underlying physics are mundane: every token is one forward pass, so making the model write out intermediate steps amounts to trading context length for serial compute depth.
Now for the deflationary reading: in 2023, this was packaged as a “$300k-a-year new profession,” yet even its staunchest defenders (see Simon Willison’s In defense of prompt engineering) listed the core skills as “communicate clearly, run experiments, take notes, cut waste”—hardly a new engineering discipline. What’s more subtle is how it ended. Once reasoning training internalized CoT into the model (which is what o1 and R1 did), the incantation “let’s think step by step” stopped doing anything. A capability that required prompt tricks in 2022 was absorbed into the model by 2025, and the trick depreciated to zero. Remember this pattern—it recurs.
ReAct: Agents Were Fully Invented in 2022
In October 2022, the ReAct paper came out. The problem it solved was practical: pure CoT is a closed-book exam. No matter how elegant the reasoning chain, every fact inside it is dredged from the model’s weights, and one wrong step compounds all the way down. ReAct’s fix was to prescribe, in the prompt, a three-part textual format:
Thought: I should look up when this actor was born
Action: Search[so-and-so]
Observation: (an external program pastes the search results back here)
Thought: OK, next...The model is halted the moment it writes the Action: line (a stop sequence). An external program parses that string, executes the API call, appends the result as Observation:, and lets the model continue. Repeat until the model declares it’s done. Closed book becomes open book.
Note what’s absent here: no new architecture, no training of any kind. ReAct is a prompt template, plus a stop token, plus a regular expression. And the core of every agent framework today is its direct descendant. In a very real sense, the agent was fully invented in October 2022; the years since have just been engineering and commercialization.
Tool Calling and MCP: There Is No Call in “Function Calling”
In the ReAct era, everyone was hand-writing regexes to parse model output, and the model would routinely hand back something malformed—wrapped in a markdown fence, missing a brace, naming a tool that doesn’t exist. In June 2023, OpenAI shipped function calling, which made output well-formedness the platform’s problem.
The flow: you pass a set of JSON Schemas describing your tools; the API serializes those schemas into text and splices them into the model’s context; the model continues the text with a correctly formatted JSON blob; the API parses it into a struct and hands it back to you; your code executes the function; then you append the result to the context and call the next round.
Notice anything? The model never executes a thing, start to finish. There is no call inside “function calling.” The model is merely asked to write a well-formed piece of JSON, and your while loop runs the errand. If you doubt that tool definitions are just text spliced into context, there’s hard evidence. Anthropic measured it themselves—hook up 5 MCP servers with 58 tools, and roughly 55K tokens are burned before the conversation even starts. If tool definitions weren’t text, they wouldn’t consume tokens. They consume tokens; therefore, they are text.
Which brings us to MCP. In November 2024, Anthropic released the Model Context Protocol; within a year, OpenAI and Google had both announced adoption. It solves a real problem: N applications connecting to M data sources used to mean N×M pieces of glue code, and MCP turns that into N+M. But what it standardizes is only how tool definitions get discovered and transported—the last mile is still the same “text in, JSON out, your code executes.” Giving your AI MCP is roughly like giving your computer a USB port: useful, but it does not make the computer any smarter.
Best of all, a year after the protocol shipped, Anthropic’s own recommended best practice became “don’t stuff all the tools into context—have the model write code that calls them,” which cut one workflow’s token bill from about 150K to about 2K. Twelve months after a protocol’s birth, the officially recommended usage is to route around its default usage—as lifecycle specimens of jargon go, it doesn’t get much more ironic.
(One fair aside: the only thing in this entire story that actually touched the inference mechanism, rather than shuffling text around, is Structured Outputs from August 2024. It uses constrained decoding, masking out every token at sampling time that would lead to invalid JSON, thereby replacing “pray the model formats correctly” with “mathematically impossible to format incorrectly.” Credit where credit is due.)
Post-Training: The Change Was Never in the Loop
By now you might ask: if ReAct existed in 2022 and function calling in 2023, why did agents only get good after 2025? Wasn’t AutoGPT (March 2023) exactly “wrap GPT-4 in a while loop and let it work on its own”—one of the fastest-starred projects in GitHub history? And then what?
And then its best-known real-world use case became burning money in circles: install a dependency, verify the install, hit an error, uninstall, reinstall, loop. Amazon researchers measured it at a 24% success rate on a shopping task. Yet the exact same loop, running on today’s frontier models, basically works. The loop’s code barely changed. The model inside it did. In between lie several layers of post-training:
Layer one: tool calling got burned into the weights. June 2023’s gpt-4-0613 was already “fine-tuned to detect when a function needs to be called”; by 2024, some models carried dedicated tool-call tokens in their tokenizers. The effect is quantifiable: on complex JSON-schema-following evals, gpt-4-0613 scored under 40%; a year later, gpt-4o-2024-08-06 scored 100%. Nobody wrote a better parser. The model stopped needing to be parsed.
Layer two: reasoning RL. o1 (September 2024) and DeepSeek-R1 (January 2025) ran reinforcement learning on chains of thought against verifiable rewards (e.g., is the math answer correct? Do the unit tests pass?), and the models spontaneously developed self-checking, backtracking, and trying different approaches. Notice that these are exactly the behaviors an agent loop needs most: self-checking maps to “did that command actually succeed?”, backtracking maps to “this path is dead, take another”—the precise antidote to AutoGPT’s infinite loops. No framework ever taught the model any of this. The reward signal did.
Layer three: RL directly on multi-turn tool-use trajectories. Anthropic shipped computer use in October 2024. From 2025 onward, the labs began training models inside SWE-bench-style real environments to finish tasks dozens of steps long, and “thinking” went from once per request to between every tool call (interleaved thinking). The results are in the numbers: when SWE-bench launched (October 2023), the strongest model resolved 1.96% of real GitHub issues; Claude Sonnet 4.5 (September 2025) reached 77.2%; this year, third-party leaderboards put the latest models somewhere around 95%. METR’s measurements give a more intuitive unit: the length of a task (in human-expert hours) that AI completes at a 50% success rate has doubled roughly every 7 months over the long run—and roughly every 3 months since 2024.
Layer four—the one that clears my name—long-context and instruction-hierarchy training. My old hot take that System Prompts make the model dumber turns out to have had a paper backing it. Lost in the Middle (2023) found that models of that generation (GPT-4 included) attend to context in a U-shape—solid at the beginning and the end, while the middle is mostly left to luck. The several thousand tokens of scaffolding a framework prepends physically shoved your actual question into this attention trough. Later models were trained specifically on data where a long system prompt and a downstream instruction must be honored together, plus an explicit instruction hierarchy (system > developer > user > tool output)—and only then did a ten-thousand-token system prompt become a free lunch. (An honest footnote: the penalty moved; it did not disappear. Today’s models still degrade over trajectories hundreds of thousands of tokens long—which is precisely the problem the newer batch of jargon below exists to handle.)
All of this yields a clean controlled experiment: bolt a 2026 framework onto a 2023 model, and it still fails in 2023 ways; bolt the 2023 AutoGPT loop onto a 2026 model, and it mostly works. The variable was never the loop.
Agent, Workflow, Harness: The War Over Definitions
So what, exactly, is an “agent”? It took the industry three years to reach a rough consensus. Simon Willison once crowdsourced definitions on Twitter and collected 211 mutually incompatible versions. Not until September 2025 did he declare that the term had finally converged: “An LLM agent runs tools in a loop to achieve a goal.” Hold that sentence up against the 2022 ReAct paper—it doesn’t contain a single component that the paper didn’t already have.
More useful than the definition is the line Anthropic drew in Building Effective Agents: if the control flow is written in code, it’s a workflow; if the model decides the control flow each turn, it’s an agent. To find out which kind your “AI agent” is, ask one question: if the model decided, this turn, to skip step two—what would happen? If the answer is “it can’t,” you have a workflow. Most products sold as agents are actually workflows—and that’s no disgrace. The essay’s whole point is to talk you down: prefer a workflow over an agent, and prefer a single call over a workflow. A company that sells models earnestly pleading with you to let the model decide less—that’s one of this industry’s rare, frame-worthy moments of honesty.
Harness (and its gerund, harness engineering) is the star of the newest round of vocabulary inflation, but the thing it names existed in 2023, when it was called scaffolding. METR wrote back then that “the quality of scaffolding and prompting appears to significantly impact the capabilities of agents.” SWE-agent (2024) supplied the cleanest evidence: same model, different tool interface (one designed specifically for models), and the SWE-bench score moves significantly. The shell determines the performance.
In 2025, the Claude Codes of the world turned the shell itself into a product. In early 2026, “harness engineering” duly went mainstream, meaning: every time the agent makes a mistake, weld a permanent fix into its environment so that this mistake becomes structurally impossible. It sounds profound, but translated, it means: take one very smart, amnesiac, occasionally confabulating intern, and set them up with linting, tests, CI, checklists, and permission boundaries. Software engineering has been building exactly this for humans for forty years. The only genuinely new part is that this particular intern shows up to work with amnesia every single time, so every rule has to live in a file, ready to be loaded into context at any moment. See? Back to the same primitive again.
As for Loop and Graph Engineering: the loop is the same while loop you’ve already met; the graph is what you get when you want to tune continuously between a “fully hard-coded pipeline” and a “fully unleashed loop” by drawing the control flow as a stateful graph with cycles (which is what frameworks like LangGraph do). The real value such frameworks provide—state persistence, resumability, observability—is distributed-systems value, not AI value. Anthropic’s essay warns, in passing, that frameworks “obscure the underlying prompts and responses, making them harder to debug.” My own rule of thumb is simpler: if you can read the full text that ultimately gets sent to the model, you don’t need the framework; if you can’t, the framework is the biggest obstacle on your debugging path.
Vibe Coding, Context Engineering, Skills: The Standard Lifecycle of a Buzzword
In February 2025, Karpathy tweeted about a new way he’d been programming—“fully give in to the vibes, embrace exponentials, and forget that the code even exists”—and named it vibe coding. The qualifier was right there in the tweet: fine for throwaway weekend projects. But the moment the word escaped, the qualifier evaporated. “Vibe coding” came to mean any use of AI to write code, production systems included. Karpathy later recalled that it had just been a throwaway shower thought. The word had quite a 2025 all the same: Collins Dictionary crowned it Word of the Year; that same year, Merriam-Webster’s word was “slop” (low-quality AI-generated content). Same year, same technology: two dictionaries picked its utopian face and its garbage face.
Context engineering’s story is shorter. In June 2025, Shopify’s CEO and Karpathy proposed, within days of each other, that it replace prompt engineering. Their reasoning was that the latter had come to mean “party tricks for talking to a chatbot,” while the real work is “the delicate art and science of filling the context window with just the right information.” The actual difference between the two terms comes down to one thing: prompt engineering assumes the text is mostly written by a human; context engineering admits that in an agent system, the text is mostly assembled by a program at runtime, with humans supplying only the templates and the policy. The term changed because the author changed—from a person to a program. The primitive didn’t: it’s still “what goes into the context window.” (Incidentally, “context engineer” as a job title is the 2023 “prompt engineer” joke on its second run. Going by industry convention, expect a third buzzword within two years.)
And then there is my personal favorite. In October 2025, Anthropic released Agent Skills, which more than a few people consider a bigger deal than MCP. What is a skill? In Simon Willison’s words: “a Markdown file telling the model how to do something.” No protocol, no server, no new infrastructure—just an instruction manual sitting in a folder, idling in context as nothing but a name and a one-line description worth a few dozen tokens, its body loaded only when judged relevant.
The same era’s “subagents” deserve a quick deflation too. A subagent is not “multiple AIs collaborating.” It is fork()—spin up a session with its own context, dump in the dirty work that generates piles of intermediate garbage (like searching or running tests), and return only the final concluding string back to the main context. It solves context pollution; it is memory management. As for the grander “multi-agent collaboration” narrative, its engineering-accurate name is “fanned-out read-only retrieval plus one summarizer.” Anthropic’s own numbers put multi-agent token consumption at roughly 15× that of a normal chat. It is not a team. It is MapReduce, and it is expensive.
Now, watch the loop close. In 2020, we wrote examples into the prompt and called it few-shot learning. In 2025, we write instruction manuals into files, load them into the prompt on demand, and call it Agent Skills. The five years in between—CoT, ReAct, function calling, MCP, agent, harness, graph, context engineering—were all optimizing one and the same thing: given a finite context window, what should go in right now? And after all of it, the industry’s most celebrated “agent capability extension mechanism” is just a Markdown file.
So: Emergence, or FOMO?
As much as I dislike the concept-mongering and the inflated rhetoric, the progress in what AI applications can actually do is not fakeable.
A typical example: early this year, with OpenClaw and its variants already everywhere, I still built my AI news-digest system as a fixed pipeline: RSS recall, coarse ranking by a small model, fine ranking by a bigger one, gravity-based re-ranking. The LLM only ever performs stateless, local judgments like scoring and headline rewriting, while when to fetch, how to dedupe, and how to sort are all governed by code written by a human. By the criterion above, it is a workflow through and through: could the model skip a step? It could not.
If I were making the choice today, I would probably just grab a mature coding-agent framework (Claude Code, Codex, OpenCode, take your pick), write one skill—yes, that Markdown file—and let the agent schedule subagents to run the pipeline and report back. In barely over a year, my attitude toward AI has traveled from “only my perfectly curated context can squeeze out its best performance, and even that is no threat to me” to “I have become the glue layer for AI agents (and the glue layer does not look hard to replace).” For that latter state of mind, read my friend’s What AI Brings Us.
Let me say upfront that none of this is meant to bash AI or write it off. My luck is that my field happens to demand keeping up with the state of the art, and I know better than most what is actually burning in this machine’s boiler room—so for me, the change has been gradual, continuous, and anticipated. But try a different vantage point and picture an ordinary 35-year-old. One year ago—3% of his life—AI was the toy that “couldn’t do anything right, entertainment only.” One year later, it out-writes, out-codes, and out-produces ordinary practitioners across text, code, audio, and video. Within that same year, his employer went from banning unreliable AI code in production to grading people on AI usage and AI-driven productivity (an observation from the internet, a phenomenon reported by multiple outlets—my own department has adopted no such measures), and some agents are now cleared to operate on production directly. What was gradual for me is a step function for him. Who wouldn’t feel the FOMO?
“I’m not afraid of AI. One mention of AI and I light up. ByteDance, Alibaba—you call that AI? That’s just vibe coding and workflow efficiency. Meta—now that’s AI: thousands laid off, all the money gone to GPUs, and I hear they’re into Tokenmaxxing too.”
Incidentally, every fact in that rant checks out. Meta laid off about eight thousand people in a single round this May while raising its 2026 capex guidance to $125–145 billion—next to the GPU budget, the layoff savings are a rounding error. As for Tokenmaxxing—employees deliberately burning tokens to juice their “AI usage” stats, complete with a grassroots token-burning leaderboard inside Meta at one point—the word only caught on this February, and by July the Wall Street Journal had already pronounced it passé, superseded by “thrift-maxxing” (please burn less). Birth, mutation, abandonment: one buzzword’s complete lifecycle in five months. The concepts earlier in this post each took two or three years to walk the same arc. Seen from that angle, AI really has delivered an enormous productivity gain.
Coda
The customary disclosure: the research for this post was done by several parallel subagents fanned out by a Claude Code Dynamic Workflow (they were not collaborating; it was brute-force MapReduce); the prose was written by a text-completion model (Claude Fable 5) sitting inside a harness, generating word after word in a tireless while loop; and my job, as the only carbon-based life form involved, was deciding what went into its context window—in this year’s jargon, context engineering; in last year’s, prompt engineering; in plain words: being the glue.
Let’s wait and see what kind of world AI ends up shaping.
BTW: Demystifying “Memory” While We’re at It
The essay proper ends here, but allow me one final stretch of self-promotion.
Late last month, a leaked transcript of Liang Wenfeng’s May closed-door meeting with investors went viral. (True to the habit of this essay, a quick disclaimer: the transcript was reconstructed from multiple circulating versions, and DeepSeek has never officially confirmed it.) Its most-quoted passage features a staircase metaphor: last year’s step was CoT, this year’s is Agent, and the step after Agent is continuous learning. As Liang reportedly put it, “what AI lacks today is not taste or intuition, but the ability to keep learning.” A human employee can learn the ropes of a company in two months, but every time you hand an AI a task, you have to spoon-feed it the full context all over again. Therefore, “the next generation of models must be able to learn continuously—otherwise, it doesn’t deserve to be called the next generation.”
Here is the interesting part: I combed through several versions of the transcript, and the word “memory” never appears. Yet “continuous learning” and “memory” are two sides of the same coin. A model cannot learn anything new precisely because it cannot remember anything—it’s that intern again, clocking in with total amnesia every single morning, leaving you to stuff the same material back into its context window over and over.
Until models truly master continuous learning—a weights-level problem that takes time to solve, even as DeepSeek’s own Engram paper from January attempts to build “conditional memory” into sparse models as a primitive—the application layer can do exactly one thing: stretch the time axis of this essay’s ultimate question. No longer “what goes into the context window right now,” but “what should go into the context window when the next session begins.” The buzzword for this is memory. And the big names are surprisingly aligned on what it should look like: Karpathy criticizes RAG because “the LLM is rediscovering knowledge from scratch on every question. There’s no accumulation,” prescribing a Markdown wiki as the agent’s long-term memory. Hassabis notes that the endgame of memory isn’t hoarding it all—like the brain, “don’t store everything, just store the important things.”
Which brings me to the customary disclosure, part two: this is exactly the problem I set out to tackle as a core developer of the open-source project OpenViking. Having read this far, you are fully equipped to see straight through it: OpenViking organizes an agent’s memories, resources, and skills into a single filesystem (every entry gets a viking:// URI). At write time, it pre-generates three tiers of summaries—L0 (a single sentence), L1 (an overview), and L2 (the full content)—so that only the L0 one-liner idles in the context window, with deeper tiers loaded only on demand. Retrieval doesn’t fish for similarity in a vector soup either: like a person rifling through a filing cabinet, it locates the most promising directory first, then drills down level by level, leaving a trajectory you can replay and debug. Sound familiar? Exactly—this is the Skills idea, “a Markdown file loaded on demand,” generalized to all context. We invented no new magic. We simply took the ultimate question—“what goes into the window right now”—and turned it from a decision a human makes by hand every time into a database you can ls, tree, and grep. (Held to this essay’s own standard: is “context database” yet another buzzword? Yes. But at least this one knows it is one.)
One final detail you can verify on the spot: the drafting of this essay spanned multiple context compactions. Every time the model inside that while loop “rebooted from amnesia,” it was OpenViking’s recall that reminded it who I am and where the essay left off. In other words, the ad you just finished reading was written from memories fed into the context window by the very product it advertises. Conflict of interest: loop closed.