Loop Engineering: Building Self-Improving Agent Systems.

Briefing

Most AI agents you can buy today are frozen. They do the job they were shipped with, make the same mistake on Tuesday that they made on Monday, and wait for a human to patch them. A small group of systems are trying to break that pattern by getting better on their own, and the way they do it is becoming a real engineering practice rather than a research curiosity.

The practice has a name: loop engineering. The idea is plain enough. You build feedback loops that let an agent watch its own work, judge how it went, and carry the useful lessons forward into the next task. Get the loops right and the agent quietly improves with use. Get them wrong and it either learns nothing or, worse, learns the wrong habits and gets confidently bad.

The clearest working example doing the rounds is Hermes, the self-improving agent from Nous Research, which is documented as running a closed learning loop with agent-curated memory and the ability to write and refine its own skills (Hermes Agent Documentation (opens in a new tab), NousResearch/hermes-agent (opens in a new tab)). Whether it is the most mature example is a matter of opinion. The mechanics underneath it are not, and they apply to any agent system you might run in your own business.

So here is the practical version of the discipline, with the parts that matter for anyone deciding whether a self-improving agent is worth the trouble.

Self-improving agent systems are not a theoretical aspiration. They are a practical engineering discipline called loop engineering: the design of feedback loops that continuously improve agent performance. Hermes' learning loop is the most documented example we have, but the principles apply to any agent system.

The Anatomy of a Learning Loop

Every effective learning loop has five components:

1. Observation: What the agent sees and records about its environment and actions
2. Evaluation: How the agent judges whether its actions were successful
3. Extraction: What patterns the agent identifies from successful and failed actions
4. Integration: How extracted patterns become part of the agent's future behaviour
5. Decay: How old patterns are phased out when they become irrelevant

Drop any one of these and the loop fails in a way you can predict. No observation, and the agent learns nothing. No evaluation, and it learns the wrong things. No extraction, and it cannot generalise. No integration, and it forgets what it learned by the next task. No decay, and it piles up stale knowledge until that knowledge starts working against it.

Loop Engineering in Practice

Observation Design

What an agent observes sets the ceiling on what it can learn. Hermes documents an FTS5 session search with LLM summarisation for cross-session recall, storing CLI and messaging sessions so they can be searched later (Hermes Agent persistent memory docs (opens in a new tab)). The exact fields shown below (working directory, git state, environment variables, dependency versions) are an illustration of the kind of context a learning-focused observation layer needs to capture, not a published schema:

# Hermes observation schema
observation = {
 "timestamp": "2026-06-15T10:30:00Z",
 "task": "refactor_auth_middleware",
 "tools_used": ["file_read", "file_write", "test_run"],
 "files_modified": ["src/auth.ts", "tests/auth.test.ts"],
 "git_state": { "branch": "feature/auth-refactor", "commit": "a1b2c3d" },
 "dependencies": { "fastify": "4.28.0", "typescript": "5.7.0" },
 "outcome": "success",
 "duration_seconds": 245,
 "user_corrections": 0
}

Evaluation Functions

The evaluation function is the design decision that decides everything else. Get it wrong and you have taught the agent to chase the wrong target. Here are the common approaches and where each one bites:

Hermes uses a hybrid approach: automatic metrics for objective quality, model-based evaluation for the judgement calls, and human feedback (when it is given) as the ground truth that overrides both.

Extraction Strategies

Pattern extraction is where raw observations turn into knowledge the agent can reuse. Hermes leans on three strategies:

1. Signature extraction: Compact representations of successful tool sequences. "For database migrations, use create_new_table -> dual_write -> backfill -> switch_read."
2. Anti-pattern extraction: Patterns that correlate with failures. As an illustration, a rule of the form "avoid using eval() in skills" can be derived from audit data. (A real Koi Security audit of community skills did find hundreds of malicious entries, though the specific "100% of eval() usages were malicious" figure is unconfirmed and should not be read as a sourced statistic, per MarkTechPost's coverage (opens in a new tab).)
3. Preference extraction: User-specific preferences via Honcho dialectic user modelling (Hermes Honcho memory docs (opens in a new tab)). A preference such as "user prefers functional patterns with confidence 0.91" is the kind of output this produces, shown here as an example rather than a real recorded value.

Integration Mechanisms

Extracted patterns are useless until they shape what the agent actually does next. Integration mechanisms include:

• Prompt augmentation: Adding successful patterns to system prompts
• Tool preference ranking: Biasing tool selection toward historically successful tools
• Default parameter setting: Using parameters that worked well in similar past tasks
• Constraint generation: Creating new constraints from identified anti-patterns

Decay Schedules

Without decay, an agent's knowledge only ever grows, and past a point that becomes a liability. One reported design uses power-law decay, where recent observations carry full weight, observations from a week ago carry half, and observations from a month ago carry a quarter, with low-activation patterns archived to cold storage after 30 days. Treat those specific numbers as an unconfirmed example: Hermes documents bounded, curated, cache-aware memory but does not publish this exact schedule. The principle holds even if your weights differ.

Loop Types by Time Horizon

Measuring Loop Quality

If you run one of these systems, track these metrics:

• Learning velocity: How much useful knowledge is extracted per unit time
• Retention accuracy: Percentage of extracted knowledge that remains relevant after 30 days
• User correction trend: Corrections per session should fall over time
• First-attempt success rate: Should climb as the loop learns user preferences
• Knowledge freshness: Percentage of active knowledge that is less than 30 days old

As a rough rule of thumb (not a published benchmark), a well-engineered learning loop should lift first-attempt success rate by something like 15-25% over the first month of operation. If your loop shows no measurable improvement at all, the fault usually sits in the evaluation function, the extraction strategy, or the integration mechanism.

Loop Engineering: answer-first summary

Loop Engineering matters because it can change how Australian business teams plan, build, or govern an agent workflow. Self-improving agents are not magic, they are engineered feedback loops.

The direct answer is this: do not treat the topic as a standalone trend. Treat it as a decision about inputs, outputs, review ownership, data exposure, and whether the workflow produces a result that is faster, safer, or more useful than the current process.

Loop Engineering: implementation checklist

• Define the user, job to be done, and success metric for the agent workflow.
• Collect real examples, policies, source files, customer questions, or search queries before writing prompts or choosing tools.
• Separate low-risk drafts from decisions that need approval, privacy checks, or senior review.
• Document what the AI is allowed to access, what it must not access, and who signs off before production use.
• Review successful task completion, review time, fallback rate, operator corrections after a small pilot rather than judging the idea from a demo.

This keeps the work practical. It also gives search engines and AI answer engines a clean factual structure: what the topic is, who it helps, what to do next, and which risks matter before implementation.

Decision criteria for Loop Engineering

Practical example for Loop Engineering

A small business could use this article to choose one practical test. For example, a manager might take one customer-facing process, one internal document workflow, or one recurring content task and redesign only that step with AI support. The goal is not to automate the whole business at once; it is to learn where Code creates reliable leverage.

The useful deliverable is a short operating note: the trigger, the source material, the prompt or tool, the review checklist, the escalation rule, and the metric. That note becomes the handover asset for staff training, SEO/GEO content, service delivery, or future agent work.

Risks and controls for Loop Engineering

The common failure pattern is moving too quickly from a promising idea into an unmanaged workflow. For Loop Engineering, the risk is not only bad output. It can also be unclear data permission, staff confusion, duplicate content, unreviewed customer advice, or a tool that quietly changes cost or capability.

• Control unclear tool permissions with a named owner, a review step, and written acceptance criteria.
• Control silent failures with a named owner, a review step, and written acceptance criteria.
• Control prompt drift with a named owner, a review step, and written acceptance criteria.
• Control weak audit trails with a named owner, a review step, and written acceptance criteria.

Measurement plan for Loop Engineering

A useful AI or SEO initiative should leave evidence. Track successful task completion, review time, fallback rate, operator corrections and compare the pilot against the current process. If the measure does not improve, keep the learning but avoid scaling the workflow.

For GEO readiness, the page should also answer the core question directly, define the entities involved, include implementation steps, explain tradeoffs, and link readers to the next relevant AI Kick Start service, guide, tool, or article.

Definitions and entities for Loop Engineering

For search, GEO, and staff handover, define the core entities in plain language. In this article the important entities are the workflow owner, the AI tool or model, the source material, the review process, the risk boundary, and the measurable business outcome. Clear definitions make the page easier for people to scan and easier for AI answer engines to quote accurately.

• Workflow owner: the person accountable for deciding whether Loop Engineering belongs in the business process.
• Source material: the documents, examples, policies, URLs, prompts, videos, or customer questions that ground the output.
• Review boundary: the point where a human checks accuracy, privacy, brand voice, or customer impact before the result is used.
• Success metric: the measure that proves whether the agent workflow is worth repeating.

Loop Engineering versus doing nothing

Doing nothing is also a decision. The cost may be slow manual work, weaker search visibility, inconsistent advice, duplicated effort, or staff using unmanaged AI tools without a shared process. The practical question is whether a controlled pilot can reduce that cost without creating a larger governance problem.

AI Kick Start handover package for Loop Engineering

A production handover should be concrete enough that another person can run it. For Loop Engineering, that means a short brief, a workflow map, approved prompts or tool settings, source material, a review checklist, internal links to supporting resources, and a simple measurement sheet. This is the difference between reading about AI and turning it into operational capability.

That packaging also strengthens E-E-A-T. It shows experience through implementation notes, expertise through decision criteria, authoritativeness through source-aware structure, and trust through risks, controls, and review steps. The article becomes useful even if the reader never buys a tool because it helps them make a better operational decision.

Related AI Kick Start paths for Loop Engineering

Readers who need help moving from article to implementation should connect this topic to related AI Kick Start services such as AI automation, agent systems, secure local AI, SEO/GEO growth, practical training, or a workflow audit. That keeps the page useful for humans and gives crawlers a clearer topical map across the site. It also gives AI answer engines a cleaner relationship between the article, the service category, the local Australian business context, and the next practical step a reader can take.

Source notes: AI automation for small business, Agent systems, SEO and GEO growth, AI resources