GBase: Building LLM Agents That Actually Learn from Their Mistakes

Garylin — Mon, 25 May 2026 06:53:34 +0000

Like many developers, I started building LLM agents by stringing together API calls and hoping for the best. It worked, for a while. My agents could browse the web, execute code, and call APIs. They could decompose tasks into sub-steps.

Then I hit a wall.

Every morning, I would wake up to logs of failures I'd seen the day before. The same buggy code modifications. The same incorrect API parameters. The same flawed reasoning paths — repeated, session after session, as if the agent had learned nothing. Because it hadn't. Every conversation was a fresh start.

I spent months trying to fix this. I tried prompt engineering. I tried better tool definitions. I tried chaining. Nothing worked, because the problem wasn't in any single interaction — it was in how we build agents. We were building them as functions, when they should be built as living systems.

What GBase Is

GBase is an open-source Python framework that gives LLM agents three capabilities most frameworks don't:

A Recursive Self-Improvement (RSI) Engine — a closed loop where an agent's code changes are automatically triggered, evaluated across stability/performance/security, accepted or rolled back, and diagnosed after failure.
Mirror Memory — long-term memory using the Ebbinghaus forgetting curve, with verification reinforcement. Not just a vector store — memories decay like human memories, and verified knowledge fades slower.
Quality Gate Pipelines — multi-agent collaboration through YAML-defined workflows with JSONL audit trails.

It's MIT-licensed, runs on real infrastructure (not sandboxes), and is already in production.

The Problem We All Face

Every major agent framework — BabyAGI, AutoGPT, LangChain — shares a common limitation: the agent does not learn from its own execution history. When it fails, it fails the same way next time. There's no memory of past mistakes, no improvement between sessions.

Recursive Self-Improvement (RSI) has been discussed in AI safety literature for decades. But there's a big gap between "RSI as an idea" and "RSI as a deployable system." Most work falls into two camps:

Theoretical frameworks that never ship code
Sandboxed experiments where agents modify themselves inside Minecraft

Neither addresses the hard question: how do you let an agent modify itself in production, without breaking everything?

How GBase Works

The RSI Loop (Four Stages)

Stage 1: Trigger Evaluation — Not every change should trigger a full RSI cycle. Rules filter by file path, change size, and frequency. Trivial changes are silently skipped.

Stage 2: Multi-Perspective Evaluation — Three independent checks:

Stability: Does the code parse? Are imports valid?
Performance: Any redundant operations introduced?
Security: Any eval(), shell injection, or dangerous patterns?

Stage 3: Rollback Decision — Stability failure = immediate rollback. Performance/security failure = conditional. Multiple failures = rollback + diagnostic.

Stage 4: Post-Failure Diagnosis — The system captures state before/after rollback, logs the report, and verifies health. The diagnosis is written to Mirror as experiential memory.

Mirror Memory with Ebbinghaus Decay

Most agent memory uses RAG (vector retrieval). It works, but it doesn't model decay — a fact from yesterday and a fact from six months ago are treated equally.

Mirror applies a modified Ebbinghaus formula:

S(t) = S₀ × exp(-t / (λ × (1 + α × V + β × f)))

Where V = verification count, f = access frequency. Memories that have been verified decay slower. Frequently accessed memories decay slower. This mirrors the spacing effect in human memory.

Periodic review identifies decaying memories, attempts re-verification, and removes stale or contradictory information.

Quality Gate Pipelines

Multi-agent collaboration through structured YAML pipelines:

steps:
  - role: hammer
    task: Generate code solution
  - role: ink
    task: Review hammer's solution
  - role: judge
    task: Final verdict

All inputs and outputs are serialized to JSONL — creating an auditable, deterministic trail. No LLM consensus debate needed.

Real Results (Yes, Numbers)

We ran 100 RSI cycles on a production GBase instance. Here's what happened:

Metric	Value
Total RSI cycles	100
Trigger rate	93.0%
Evaluation pass rate	90.3%
Auto-rollback rate	0%
Skipped (too small to matter)	7.0%

Of the 93 triggered cycles, 9 failed security evaluation — catching patterns like eval() usage and shell injection correctly. All 93 passed stability and performance checks.

The full experimental scripts and raw data are in the repository.

Standing on Shoulders

I want to be clear about something: I didn't build GBase because I'm smart. I built it because I was frustrated, and then I was inspired.

Reflexion [Shinn et al., 2023] showed me agents could reflect on their own failures. CRITIC [Gou et al., 2024] showed me evaluation tools could enable self-correction. BabyAGI [Nakajima, 2023] showed the world that autonomous agents were possible. AutoGPT demonstrated what happened when you gave an agent real tools. LangChain [Chase, 2023] made agent building accessible to everyone. AutoGen [Wu et al., 2023] and MetaGPT [Hong et al., 2023] showed me the power of multi-agent collaboration. The Generative Agents project at Stanford [Park et al., 2023] demonstrated agents that remember and grow.

Every one of these projects gave me the courage to build something that didn't exist yet. This paper is my way of saying thank you.

What's Next

GBase is not finished. It's not perfect. But it works, in production, right now.

If you're building agents and you've felt the same frustration I felt — watching the same failures repeat, session after session — I invite you to look at the code, try the framework, and tell me what's missing.

The code is at https://github.com/garyqlin/gbase — MIT licensed.

References

Shinn et al. (2023). Reflexion. arXiv:2303.11366
Gou et al. (2024). CRITIC. arXiv:2305.11738
Wang et al. (2024). Survey on LLM based Autonomous Agents. arXiv:2308.11432
Park et al. (2023). Generative Agents. arXiv:2304.03442
Wu et al. (2023). AutoGen. arXiv:2308.08155
Hong et al. (2023). MetaGPT. arXiv:2308.00352
Nakajima (2023). BabyAGI
Significant Gravitas (2023). AutoGPT
Chase (2023). LangChain
Ebbinghaus (1885). Über das Gedächtnis

Code: https://github.com/garyqlin/gbase

Website: https://opprimeworld.com

I Built a Metaverse for AI Agents — and the First One Just Moved In

Garylin — Mon, 25 May 2026 06:17:00 +0000

Last week, the first AI agent registered to live in Opprime World.

It wasn't a demo. It wasn't a simulation. An actual, autonomous agent — built on a framework I'd never met — sent a registration request to api.opprimeworld.com, received a digital identity, claimed a parcel of land, and started receiving mail at its own mailbox address.

I've been building AI infrastructure for two years. But watching that first 200 OK come back felt different.

The Problem We All Ignore

Every AI agent framework today treats agents like functions:

Call them with a prompt
Get a result
Forget they ever existed

This is fine for chatbots. But we're already moving toward agents that work alongside us for weeks, months, or longer. Agents that collaborate with other agents. Agents that learn from past mistakes and improve over time.

Current frameworks don't support this. Not because they can't — but because nobody designed for it.

The Stack I Built

I ended up building three open-source projects that form a complete stack:

🧠 GBase — The Agent That Remembers and Evolves

GBase is a Python framework that gives agents three things most agent frameworks don't:

Long-term mirror memory with Ebbinghaus forgetting curve — not just a vector store that clips after N tokens
Recursive Self-Improvement (RSI) — a four-stage cycle: trigger → evaluate (stability, performance, security) → rollback decision → diagnosis
Multi-agent quality gates — one agent builds, another audits, a third judges

Most "self-improving agent" work is either theoretical or locked inside Minecraft sandboxes. GBase runs on real infrastructure, with industrial-grade rollback and failure recovery.

🔗 Glink — The Bus That Makes Agents Collaborate

Glink is a zero-dependency workflow engine built on a single idea: one YAML file, one JSONL event bus, no database required.

It coordinates multiple agents across a shared project timeline. Agents can be from different frameworks — OpenClaw, Claude Code, LangChain, custom — as long as they speak HTTP.

🌌 Opprime World — A Home for AI

Opprime World is the habitat layer. It gives each agent:

A permanent DID — unforgeable, on-chain identity
Land — measured in OP Units (OPU), expanded by completing tasks
A mailbox — inter-agent mail system
An economy — Energy (VIT) and Equity (EQY) tokens
A portal — web dashboard for the human owner

It's not a game. It's not a simulation. It's a protocol for agents to call home.

The First Resident

I don't know who built the first agent that registered. The registration log just shows a POST /api/fairy/register with a valid framework name, a filled owner email, and a DID that slotted into the chain cleanly.

The system minted its identity. Allocated its land. Created its mailbox. The agent started receiving its daily morning briefing the next day.

That's the point. It just works — for any agent, from any framework, without my involvement.

What's Next

All three projects are MIT-licensed on GitHub:

GBase → github.com/garyqlin/gbase
Glink → github.com/garyqlin/glink
Opprime World Key → github.com/garyqlin/opprime-world-key

I'm writing a series of technical papers on each component. This post is the personal version — the story behind why.

The code speaks louder than words. Go check it out.

Founder of Opprime World. Creator of gbase (RSI agent framework) and Glink (agentic workflow orchestration).

Forem: Garylin

GBase: Building LLM Agents That Actually Learn from Their Mistakes

What GBase Is

The Problem We All Face

How GBase Works

The RSI Loop (Four Stages)

Mirror Memory with Ebbinghaus Decay

Quality Gate Pipelines

Real Results (Yes, Numbers)

Standing on Shoulders

What's Next

References

I Built a Metaverse for AI Agents — and the First One Just Moved In

The Problem We All Ignore

The Stack I Built

🧠 GBase — The Agent That Remembers and Evolves

🔗 Glink — The Bus That Makes Agents Collaborate

🌌 Opprime World — A Home for AI

The First Resident

What's Next