If agentic engineering had a package.json, we'd be three major versions in. Each upgrade broke the old way of working, which is what a major version is supposed to do.
I want to write the version history down properly, because when I was learning this there was almost nothing that broke it into pieces a normal person could digest. You either read papers or you read hype threads. Nothing in between. This is my attempt at the in-between thing, with the receipts of someone who was around for each release.
Where I come into this
My first contact was hosting tiny LLMs on my RTX 3060 through LM Studio, back when LM Studio was barely a product. The models were small, the outputs were rough, and the setup ate a weekend. Then came a college hackathon where my team tried to build a coding extension for our campus network. We got maybe 70% of the way and never finished on time. The hardest part wasn't the extension. It was getting the LLM stood up at all.
That problem has mostly dissolved. The clearest sign: PewDiePie, a creator I've followed forever, shipped Odysseus at the end of May, a self-hosted AI workspace that picked up 30,000+ GitHub stars in its first 48 hours. When running your own AI stack goes from "weekend of pain on a 3060" to "a YouTuber publishes one and the internet installs it," the floor has moved.
The application layer moved too, in three distinct releases.
v1: prompting
The first era was instructions. You wrote a system prompt telling the model what it is and what it does, and that prompt was most of the product. The craft had names for its levels: zero-shot, where you give the instruction cold with no examples. One-shot, where you include a single worked example. Few-shot, where you include several and let the model infer the pattern. Fine-tuning existed for teams with budgets, but for most companies the prompt was the whole tuning knob.
It worked better than it had any right to. It also capped out fast, because the model only knew what you pasted into the box.
v2: context
The second era stopped obsessing over the instruction and started engineering what the model knows. Retrieval (RAG) to pull in your documents. Memory so the agent isn't an amnesiac between sessions. Background, project details, history, all curated into the window so the model works on top of a real information layer instead of vibes.
This is the upgrade most teams have actually installed. If your agent setup has a vector store and some memory management bolted on, you're living in v2, and honestly it's a fine place to live.
v3: harness
The current era barely touches the prompt. Harness engineering is designing the runtime around the model: which tools it can call, which it can't, permission gates, sandboxes, feedback loops, the whole operational environment. The bet is that a mid model in a great harness beats a great model in no harness, and from what I've seen building agent systems at Express Analytics, the bet holds.
MCP is the obvious exhibit. I watched people argue it could never scale, and now an MCP server is table stakes for any serious tool. The protocol won because v3 needed a standard way to wire tools into the harness, and it was standing there.
This is the layer I spend my time in now, and it's where the interesting failures live. Prompts fail loudly. Harnesses fail quietly, which is worse.
unreleased: self-healing
The next major is agents that improve themselves. Hermes Agent from Nous Research generates its own skill files from your repeated workflows, so it gets measurably better at the things you actually do. It crossed 140,000 GitHub stars in under three months. OpenClaw runs 24/7 and has a whole ecosystem of self-healing skills, including autonomous recovery tiers that fix the agent when it falls over at 3am.
Adoption is still pending, and there's a cautionary tale already on the books. Earlier this year, Claude Code users discovered that merely having the string "hermes.md" in their git commit history tripped a third-party harness detection routine and silently rerouted their subscription usage to per-token API billing. Some woke up to roughly $200 in surprise charges. Refunds reportedly followed, but the lesson stands: when the harness makes decisions you can't see, the failure modes get expensive and weird.
Which is why no production system I've touched is fully agent-driven. There's money on the line, so some workflows stay rule-based, some go agentic, and the actual engineering is deciding which is which. Every company drawing this line is doing harness engineering, whether they call it that or not.
The part I'd underline
The model was never the product. Each version wrapped a thicker layer of engineering around roughly the same core, and the layer is where the quality comes from. So the skill that compounds isn't memorizing any of these eras. It's keeping your hands on the tools while they change. Interacting with agents, building harnesses badly, watching where they break, and fixing them taught me more than any amount of reading about them.
I'll also admit what my workflow looks like: a lot of it is vibe-coded now. I rarely read every line the agent writes. But I still read the code that matters, and knowing where things live in my own codebase is most of why I can debug fast. I can point the agent at the right file instead of the right vibe. I write MD files for my team so their agents start with shared context instead of guesses. The agent still won't invent the failure mode that bites you in production. That part stays on you.
Funny epilogue: that unfinished hackathon Chrome extension came back around. I recently built one internally at work, for outreach, and shipped it. Largely vibe-coded, might bite me later, taught me things the 70% version never could. Full circle, with better tooling.
What I'm still figuring out
First, a caveat I want on the record: this three-version story is a lens, not a standard. Agentic engineering isn't standardized anywhere. The mechanisms vary by company, by requirement, by industry, and plenty of teams would slice the layers differently than I have. I also haven't touched evals, which sit underneath all three versions and deserve a post of their own.
Beyond that: where the line between rule-based and agent-driven should sit, case by case. I redraw it more often than I'd like. And whether self-healing agents are the next major version or a long-running beta. I genuinely can't tell yet, and I distrust anyone who says they can.
I'm planning to build some small public projects in