The harness, not the model: why long-running AI agents need your KB as text

If you work with GeneXus, something happened this year worth looking at closely. The conversation about AI coding stopped revolving around "which model autocompletes best" and moved somewhere else: agents that pick up a task, work for hours — sometimes days — run out of context, start over from scratch, and still reach the end. The news isn't a bigger model. It's everything around it.

The community building these tools has settled on a name for "everything around it": the harness.

From autocomplete to the agent that works for hours

A year ago, AI coding was, in practice, very good autocomplete: you asked for a function and it wrote one. Today you hand it a whole task — "find why this process fails and fix it" — and the agent goes off on its own: it reads the code, runs tests, gets it wrong, corrects, and keeps going.

The catch is that an agent works in sessions. Each context window is finite, and no real task fits in one. When the agent runs out of context, the next session starts with no memory of what came before. Anthropic published an engineering piece this year — Effective harnesses for long-running agents — devoted to exactly that problem: how to make an agent progress consistently across many context windows. The answer wasn't "a smarter model." It was structure around the model.

What a "harness" is

A harness is the scaffolding around the model that makes it reliable on a long task. The pieces are always the same:

• Persistent state that survives a session restart — typically a progress file plus Git history — so the agent understands in seconds where it left off.
• Context handoffs: instructions that tell the agent, the moment it opens the project, what this is and how work is done here.
• Verification: a step that checks what the agent proposes before it becomes final.
• Controlled execution and a grounded knowledge base, so it doesn't make things up.

The detail that matters: everything an agent carries between sessions, it carries as text. The model, however large, is the small part. What makes it reliable is the harness — and the harness is text: files, diffs, notes, documentation.

The problem with a binary KB

Here's the uncomfortable part for GeneXus. A Knowledge Base lives in a binary database. An agent can't read it, can't diff it, can't leave a note inside it. Without externalization, every session starts blind: no persistent state in text, no handoff, nothing to version.

GeneXus's thesis was always a beautiful one: knowledge outlives technology. Thirty years on, KBs that started in GeneXus X still run banks. The point is that for an agent to use that knowledge, it first has to be able to read it as text.

Your Knowledge Base can already be a harness

This is what KBbridge does, and it's worth walking piece by piece against the definition above — because it isn't an analogy, it's literally the same list:

• Persistent, versionable state → KBbridge externalizes the KB to plain text and keeps it in Git. Every object is a file. The agent reads it, diffs it, and the history is the audit log.
• The context handoff → the moment you open the project, the files each agent reads are already there: CLAUDE.md, CODEX.md, copilot-instructions.md, .cursorrules and the rest. The agent knows this is GeneXus from the first second, without you explaining it. (The industry is heading the same way: AGENTS.md, the agent-instructions format, has been an open standard under the Linux Foundation since late 2025.)
• Verification → a full validation pass before every write-back to the KB, on 10-second cycles. The agent proposes; KBbridge validates before touching the KB.
• Grounded knowledge → a local documentation MCP server: 46,750 chunks covering GeneXus versions 9 through 18, running offline, no API keys, no outbound traffic. The agent doesn't guess how something is done in GeneXus — it looks it up.
• Provider choice → any LLM, present or future. Once the KB is text, you pick who reads it — including a self-hosted model, with nothing leaving your network.

Why this matters right now

The rails are standardizing. MCP — the protocol an agent uses to reach tools and context — was donated in late 2025 to the Linux Foundation, has passed 97 million installs, and AGENTS.md is now an open standard. The shape AI coding is taking is open, text-based, and provider-agnostic.

That shape is, word for word, GeneXus's promise from 30 years ago: that knowledge shouldn't depend on the technology of the moment. KBbridge replaces none of that and competes with none of the platform. It builds the bridge so that three decades of knowledge live on in the era of agents.

Fernando Leyendeker, at entrenar.se, put it better than any argument: inside KB Editor, he gave the AI access to the code and logs of a bug his team had been unable to identify for months, went for a coffee, and came back to find it solved — and tested by the AI itself. That's a long-running agent working with a good harness. The model did its part; the harness made it reliable.

To try it

If you want to see your KB turned into something an agent can read, version, and validate, start with Getting Started. There's a 15-day free trial, no card required.

Built by GeneXus developers, for GeneXus developers.