If you have spent any time working with AI agents in software development, you will recognise the pattern. On Monday, your coding agent understands your project inside out. By Wednesday, the very same agent stares blankly at a task it handled flawlessly two days earlier. It has not become less capable — it has simply forgotten. Its context was summarised, compressed and quietly discarded, and with it went everything it had learnt about your codebase, your conventions and your preferences.
For production teams, this is more than an annoyance. It is the single biggest obstacle to using AI coding agents for serious, sustained engineering work. But a solution is emerging — and it is surprisingly simple. It is called skills, and combined with version control and self-improvement loops, skills are quietly becoming the new memory of AI agents.
At Software Planet Group, we have spent nearly three decades watching technologies come and go — from Delphi and FoxPro through Java, Ruby on Rails and React to Type Script, C#, Kubernetes and modern DevSecOps platforms. If that history has taught us anything, it is that engineering process outlasts any single tool. The rise of agent skills is a case in point: beneath the hype sits a genuinely sound engineering idea.
A Brief History: From Chatbots to Harnesses
To understand why skills matter, it helps to retrace how we arrived here.
2022–2023: the chat era. Large language models such as GPT-3 and the original ChatGPT could answer questions in text — and nothing more. No memory, no tools, no ability to act.
2023: ReAct agents. The ReAct pattern gave models a choice: respond with text or call a function. An agent could now invoke a tool, observe the result, adjust its approach and try again — the first genuine agentic loop. Deceptively simple, this feedback cycle still underpins everything that has followed.
2024–2025: the scaffolding years. Frameworks such as LangChain, LlamaIndex and later LangGraph let teams chain calls, branch them into graphs and orchestrate multi-agent systems — a planner agent, a critic agent, an executor agent — using toolkits like AutoGen. Vector databases and retrieval-augmented generation (RAG) bolted external knowledge onto the model. The industry built ever more elaborate scaffolding around the LLM to extend what it could do.
Late 2025 onwards: the great simplification. Then something unexpected happened. It turned out that most tasks did not need an intricate agent graph at all. A simple agent with a handful of general-purpose tools — read a file, edit a file, run a shell command — given a well-framed task and access to the right files, would find its own way to the solution. The era of the universal agent had begun, and with it came a new word: the harness.
What exactly is a harness?
A harness is an AI agent wrapped in a small, general set of tools and a run loop: keep calling tools until the task is done, then report back. A good harness manages its own context, spawns subagents without dragging its full history along, recovers gracefully from dropped connections and failed commands, and honours a set of de facto conventions — an AGENTS.md or CLAUDE.md file describing the project, skill directories, optional MCP connections.
Anthropic’s Claude Code is the canonical example; OpenAI’s Codex CLI and, in a broader sense, Cursor follow the same pattern, while open-source projects such as OpenClaw and Hermes are built on the concept from the ground up. Tellingly, at a recent AI hackathon, nineteen of the top twenty teams had built their back ends on harnesses. Among engineers working at the frontier, the debate is effectively over.
What Are AI Agent Skills?
An agent skill is a directory containing a short SKILL.md description of a capability, detailed usage instructions, and any scripts or resources the capability needs. The agent loads only the short description into its context; the full instructions are read on demand, when the skill is actually used.
That last sentence carries the crucial insight, so it is worth unpacking.
The context problem
Every tool an agent can call must be described in its context window — and real-world tool descriptions are rarely short. A production tool for something as sensitive as blocking a bank card, for instance, must encode pages of business logic: when to block, when not to, which checks to run first. Give an agent thirty such tools and you have consumed most of its context before it reads a single line of your request. Worse, models demonstrably become confused when juggling large tool inventories; in practice, few harnesses ship with more than thirty to fifty built-in tools, because beyond that even frontier models begin to falter.
Two-stage loading
Skills sidestep the problem with two-stage loading. Only the brief description — a sentence or two — sits in the agent’s context. When the agent decides a skill is relevant, it opens the directory, reads as much of the full documentation as it needs, and follows the instructions, running any bundled Python or Bash scripts along the way.
The economics are transformative. A recent Hermes installation shipped with 56 skills out of the box and comfortably grew past 100 within weeks of daily use — with context to spare. Expressed as conventional tools, that inventory would have exhausted the context window in a couple of requests.
There is a second, quieter benefit: skills are radically cheap to create. Building an MCP server requires a developer. Writing a skill requires the ability to write clear instructions — in any language. Skills can be shared through a Git repository, a company wiki or, frankly, a messaging app.
Skills vs MCP: Which Should Your Team Use?
The Model Context Protocol (MCP), introduced by Anthropic in late 2024, standardised how agents connect to external services, and marketplaces of MCP servers flourished. But classic MCP inherits the context problem: connect two or three servers and your agent may be carrying a hundred tool definitions it will never use.
Our rule of thumb for production teams:
Choose skills when your agent handles varied, unpredictable tasks; when different scenarios need entirely different tools; or when the total tool count exceeds roughly five. The pay-per-use loading keeps the agent sharp.
Choose MCP when your agent is narrowly specialised, processes a steady stream of similar tasks, and calls the same small set of tools — fewer than about five — on nearly every request. Here the always-loaded definitions cost little and save a round trip.
The boundary, it should be said, is already blurring. Modern harnesses — Claude Code among them — increasingly wrap MCP servers as skills, generating a description file and deferring the tool definitions until they are needed. MCP is not going anywhere; it is simply being absorbed into the skills model.
Skills + Data + Git: The New Agent Memory
Here is where the story gets genuinely interesting for anyone running bespoke software development in production.
A classic skill contains instructions and tools — code, in effect, but no data. Add the data the skill operates on, plus the history of its own evolution, into the same directory, store the whole thing as a Git repository, and something remarkable emerges: a skill-first architecture in which the skill, not the agent, is the durable centre of the system.
Consider what this makes possible:
- Multiple agents, one memory. A developer opens the skill repository in Cursor or Claude Code for heavy, hands-on work during the day. In the evening, a message to a Telegram-connected Hermes or OpenClaw instance — “add this invoice”, “what did we decide about the pricing module?” — hits the same repository, pulls the latest state and answers with full context. A CI/CD pipeline can work against it overnight.
- Collisions solved by Git, not by committee. Concurrent edits by multiple agents and humans are exactly the collision problem databases have battled for decades. Git handles it natively — and where merge conflicts once required a human, modern harnesses resolve most of them autonomously. Whole classes of collaborative systems can now be built on a Git repository rather than a transactional database.
- Knowledge that survives the session. This is the headline. Traditional agent memory relied on RAG pipelines and conversation search, where a retrieval system decided — before the model even started — what was relevant. With data-rich skills, the agent itself decides what to load into context, when, and how much. The information about your project lives in the skill and surfaces precisely when the skill activates.
Two disciplines keep such systems healthy. First, a hard rule in the skill’s instructions: pull before you work, commit and push when you finish. Second, backpressure — a CI pipeline around the agent that validates its output and pushes it back when it drifts. Agents left unsupervised have a documented tendency to invent tasks nobody asked for; automated quality gates catch the drift early.
Self-Improving Agents in Practice
The most forward-looking harnesses do not merely use skills — they create and refine them. Hermes is the clearest example of a skill-first harness today, and its mechanics are worth studying.
Automatic skill creation. Whenever Hermes spends more than five tool calls on a task, it considers capturing the workflow as a new skill — turning one-off effort into reusable capability.
The curator. A background process continuously maintains the skill library. Skills unused for 30 days are deactivated (their descriptions no longer load by default); after 90 days they are archived. Once a week, a consolidation pass analyses whether small, overlapping skills should be merged into larger ones, keeping the library — and the context it consumes — lean.
Feedback-driven refinement. In one real-world workflow, a CV-screening skill was corrected over ten to twenty iterations of simple human feedback (“we only hire hybrid, not fully remote”; “if the candidate lists a GitHub profile, review their open-source contributions”). Each correction was folded back into the skill’s instructions. The end state: a screening assistant with roughly a 10% error rate against expert judgement, built without writing a line of conventional code.
The same loop works on engineering problems directly. In an experiment inspired by Andrej Karpathy’s auto-agent approach, a skill was pointed at an agent’s own source code and a benchmark: propose a hypothesis, re-run the benchmark, keep the change if the score improves, revert if it does not. Left to run over a weekend, the agent improved its score from 1 to 11 of 89 Tau-bench tasks — an elevenfold gain, achieved autonomously and, on inspection, without overfitting.
If this sounds familiar, it should. Continuous learning, collective code ownership, short feedback cycles, ruthless refactoring of what no longer serves — these are the Extreme Programming principles our teams have practised since the mid-2000s, drawn from Kent Beck, Martin Fowler and the early Agile movement. Self-improving agents are those same principles, executed by software. The teams that already live this culture will find agentic workflows a natural extension of how they work; the teams that never adopted it will discover that agents amplify process weaknesses just as readily as strengths.
What Comes Next: Agentic Loops
A brief look over the horizon. The inner ReAct loop of a harness is increasingly being wrapped in outer loops. The Ralph loop — popularised by Geoffrey Huntley — simply restarts the agent on the same task, indefinitely: “continue the task, continue the task”. Because each restart resets the context while preserving the accumulated artefacts on disk, the agent stays inside the model’s “smart zone” (roughly the first third of its context window, where reasoning quality peaks) and can work productively for days or weeks. Layer a meta loop on top — periodically archiving all artefacts and forcing a fresh start from zero to combat the mode collapse Karpathy has described, where a model “explores” the same solution in different words — and you have systems capable of investigating a problem from genuinely different directions. The industry has even coined a term for the destination: the dark factory, an agentic system that runs without a human in the loop at all, like a fully automated plant where nobody needs to turn the lights on.
These patterns are early, but they signal where AI agents in software development are heading in 2026 and 2027 — and skills, as the persistent memory layer, are what make long-running loops coherent rather than chaotic.
What This Means for Software Teams
Practical takeaways for teams considering agentic workflows in production:
- Adopt a harness, not a framework zoo. For most engineering tasks, a well-configured Claude Code, Codex CLI or Hermes will outperform a hand-built agent graph — at a fraction of the maintenance cost.
- Encode your team’s knowledge as skills. Coding conventions, review checklists, deployment runbooks, domain rules — anything you would explain to a new starter belongs in a skill. Two-stage loading means the cost of a large library is negligible.
- Put skills and their data in Git. Version control gives you shared memory across agents, humans and pipelines, plus an audit trail of how the knowledge evolved.
- Build backpressure before you build autonomy. CI gates, automated tests and validation loops are what separate a productive agent from an expensive generator of plausible-looking noise.
- Prune and consolidate. Memory that only grows eventually becomes indistinguishable from noise. Schedule curation — automated if your harness supports it, manual if not.
None of this removes the need for engineering judgement. If anything, it raises the stakes: agents amplify the process around them. A team with strong testing culture, clear ownership and disciplined delivery will get compounding returns from agentic workflows; a team without them will get compounding chaos, faster.
That is precisely the kind of challenge we enjoy. For nearly thirty years, Software Planet Group has specialised in complex SaaS platforms and web products built under high uncertainty — the projects for which no established playbook exists yet. Agentic development is today’s version of that frontier. If you are exploring how AI coding agents, skills and self-improving workflows could fit into your delivery process — or you need a partner who can tell you honestly whether they should — get in touch. Sometimes the best solution is a sophisticated agentic pipeline. Sometimes, as one of our favourite internal stories goes, it is a set of coloured envelopes. Our job is to know the difference.
Software Planet Group is a UK-based software development company specialising in bespoke SaaS platforms, web products and complex integration projects. Our engineering culture is rooted in Extreme Programming and the early Agile movement, and our teams have delivered software for organisations including Xerox, Nokia and Cisco.
