Published on: July 3, 2026
Ready to accelerate your breakthrough? Send yourself an Un-Robocall™ • Get transcript when logged in
Send Strategic Nudge (30 seconds)Green in-lane · amber a little out · red drift. Every panel is a real commit, byte-identical on recompute. Tap any panel to open its shareable receipt.
Ben Goertzel (CEO, SingularityNET / BGI Labs) and Kai Zen Bickle (Chief Ethics Officer, BGI Labs) bet human-level AGI within two to four years [0:00], on The Beyond Tomorrow Podcast, on systems that recursively self-improve — a next-token predictor wired to an explicit logic-reasoning engine and a long-term memory store, on the theory that better retrieval plus more context finally bridges the gap. Goertzel names the actual architecture: Omega Claw, an agentic wrapper shipping "in a couple weeks" that is "like OpenClaw but with better long-term memory, better reasoning, and it can modify its own software code as it goes, in the vein of self-improvement" [1:18:56]. We believe that bet is measuring the wrong axis. Handing a model a database of your rules doesn't give it domain mastery. It gives it a goldfish's tank: the model can fetch the rule perfectly, apply it for exactly as long as it's sitting in context, and lose all trace of why the rule mattered the instant that context rolls off. It isn't broken memory. It's memory that was never actually grounded in the thing it's supposed to remember — closer to a note taped to the tank than a fish that learned to swim in it.
That reframes what a hallucination actually is. Not a data error, not the model being "wrong" in the way a calculator is wrong. A hallucination is generally correct and specifically wrong — the model reaches for the broadly plausible move because that's what general capability optimizes for, and the broadly plausible move is very often not the narrow, grounded, authorized move for the exact task in front of it. General intelligence doesn't buy you grip on a narrow slice. Sometimes it actively works against grip, because the more powerful the general reach, the more confidently it drifts toward the statistical mean instead of the specific edge case your domain actually needs.
You've had this exact moment if you've run a coding agent for more than a week. It nails your style guide for six commits in a row, gets your architecture, respects the one pattern you told it never to use — and on the seventh commit, calmly does the thing you told it never to do, in a way that reads as confident, not confused. Nothing about its general competence dropped. The instruction is still sitting right there in its context window. It just didn't hold. That's the goldfish tank, felt from the outside: retrieval is not retention, and a rule you can fetch is not a rule you've grounded. Bigger context windows make the tank bigger. They don't make the fish remember the tank was ever there.
"It knows the rule" and "it stays inside the rule" are two different claims, and only one of them is checkable without reading every token the model produced. The other one — did it actually stay — is a placement question, not a knowledge question.
Here's what you get to carry out of this and back into your own team's standup: two words that aren't synonyms, even though most rooms use them like they are. Deterministic means reproducible — same input, same output, you can replay it. Decidable means provable in advance — you can know, before the fact, whether the property you care about holds. An agent can be perfectly deterministic and still be operating on a property — "will this stay inside the domain I authorized" — that is formally undecidable, in the Rice's-theorem sense: no test written in advance settles it for a Turing-complete system in general. The single forward pass through a model is bounded and tame; the deployed loop around it — memory, tools, retries, self-modification — is exactly the kind of system Rice's theorem applies to. That's the contribution worth naming out loud the next time someone in the room says "it hallucinated": hallucinated is a symptom word. Left its authorized domain, generally-plausibly, specifically wrong is the mechanism, and mechanisms are the only thing you can build a fix around.
The growth this buys you is a mental model with two axes instead of one. Most AGI-timeline arguments plot a single line: capability, going up, presumably dragging every other good property up with it. Put grip — "how reliably does the system stay inside the domain it was actually authorized for" — on its own, second axis, and the picture changes. A system can climb the capability axis fast while its grip axis stays flat, or even falls, because nothing about being more generally capable teaches a system where the fence is on any one narrow job. That's why betting an AGI timeline on recursive self-improvement is scarier than it sounds once you separate the axes: a system that edits its own weights or its own code while its grip is already slipping doesn't self-correct toward the fence. It compounds whatever direction it was already drifting, faster, because the next iteration inherits the last iteration's ungrounded confidence along with its capability gains. Growth on one axis, unmeasured on the other, is not progress. It's variance with better PR.
Three honest gaps show up across the life of this post. One is resolved, one was already fixed and guarded, one is brand new — and all three are more useful open than smoothed over.
The first has flipped from unknown to known. At publish time we said we couldn't pull a transcript for the debate this post responds to. That was wrong in an interesting way: the transcript was already sitting in our own scratchpad, and no rule in our routing lexicon pointed the request at it — so we described the argument secondhand instead of quoting it. Having now read it directly, it holds up, and it gets sharper with real language attached: the Omega Claw quote above [1:18:56] is Goertzel's own words, not our paraphrase of them. Separately, and before we opened this transcript ourselves, a first pass on the same source had already been run through a generic reasoning model primed with our own physical-grounding test — does the claimed meaning survive contact with physical memory position, not just software state (call it the S=P=H test). That pass landed on the same critique independently: Goertzel's Linux-and-internet analogy for why AGI should roll out decentralized [0:35:42] works for Linux because a compiled instruction hits the same physical register every time — it's decidable by construction. A decentralized network of Omega Claw agents, each losing grip on its own slice every second, doesn't inherit that property just because the code is open. Two independent passes landing on the same failure mode is better evidence than either pass alone.
The second gap was already fixed by the time you're reading this. While composing the first version of this post, our own prompt-time lens — the deterministic router that reads every request and injects the load-bearing rules for whatever domain it thinks it's in — misrouted. The request was, in plain language, "write a blog post using our canonical format." The lens filed it under our on-chip Rust ballistic-walk domain instead, and handed back rules about .thetacog/pmu/src/ and the chip substrate — generally in the neighborhood (we did mention our own walk mechanism in the same breath), specifically the wrong lane for the actual job. We didn't have to invent an example of "generally correct, specifically wrong." Our own decidable-placement instrument produced one, in real time, about the exact claim this post makes.
The lens misrouting mid-argument isn't an embarrassment we're burying — it's the cleanest evidence in the whole post. General keyword overlap ("PMU," "lens," "Rust") pulled a broadly plausible domain instead of the specifically correct one. That is the entire thesis, caught on our own hardware, about our own hardware.
The third gap is new, and we didn't have to go looking for it. The transcript itself loses grip before it finishes its own strongest point. Its closing paragraph walks straight up to the sharpest version of the recursive-self-improvement argument — "But if we accept that current models suffer from the 'goldfish' problem and lose grip on specific domains," — and then stops. No period, no next clause; the file just ends there. We're not going to invent the missing half to make our own case land harder. The gap stays open, flagged, exactly where the source ran out.
Here's what we're actually sure about, and it's worth separating from everything above that's a reframe or a bet. Rice's theorem doesn't get weaker as models get stronger — it's a proof about any sufficiently general computational system, not a comment on today's architectures, so "wait for GPT-7" isn't a rebuttal to it any more than a faster computer is a rebuttal to the halting problem. That's a mathematical certainty, not an empirical one, and it holds whether the AGI-timeline debate resolves in two years or twenty. Second: our own walk — the mechanism that produces the "in-domain, out, or unplaced" verdict we keep pointing at — is real silicon, not a simulation of one, and it runs fast enough to matter: a full recursive ballistic walk on-chip completes in the low tens of milliseconds, sustaining well over a million walks per second on ordinary hardware. Speed here isn't a vanity number — it's the certainty that the check is cheap enough to run on every single output, not sampled occasionally the way an expensive human or LLM review would have to be. Third: the breach frequency isn't a projection. It's a number sitting in a ledger today — 25.6% of sealed attestations crossed the strike, with a real 95% confidence interval, as we published two days ago — measurable now, on real work, independent of whatever the capability axis does next.
Here's the significance for you, specifically. Once you separate capability from grip, you stop being a participant in the timeline argument and become the person who can tell everyone else which axis they're actually debating. "Two to four years to human-level AGI" is a capability-axis claim. It says nothing about grip, and grip is the axis that determines whether a more capable, recursively self-improving system becomes safer or catastrophically less predictable as it climbs. You don't need to resolve the timeline debate to be right about this — you need one instrument that measures grip continuously, independent of how capable the underlying model gets, and the standing to demand it before anyone signs off on letting a system modify itself.
Picture the two teams six months after that system ships. One team asked for a grip receipt before every self-modification round — a signed, recomputable verdict on whether the new version stayed inside its authorized domain — and can point to a time series showing exactly when drift started compounding, if it ever did. The other team asked how capable the new version tested, got a good number, and shipped. When something goes wrong in the second team, nobody can say whether it was one bad decision or the visible tip of six months of ungrounded compounding, because nobody was measuring the axis where compounding actually lives. You get to be the person in the room who already knew which team you wanted to be on.
The academic side, in the order the argument needs them. The undecidability claim is Rice's theorem (Rice, 1953), sitting on the halting problem (Turing, 1936): no algorithm can decide, in general, a non-trivial semantic property of what an arbitrary program will do. The goldfish framing has real precedent under "catastrophic forgetting" — a network optimized further on a new task can silently lose a previously learned one (McCloskey & Cohen, 1989), because nothing about ordinary optimization protects the boundary between what should and shouldn't change; later work (Kirkpatrick et al., 2017) tried to patch this with elastic weight consolidation, penalizing changes to weights that mattered for earlier tasks — a real mitigation, and still a software-side patch on a grounding problem, not a resolution of it. That grounding problem itself has a name older than the current AI wave: the symbol grounding problem (Harnad, 1990) — the observation that a system manipulating symbols according to their shape, with no causal connection between the symbol and the thing it refers to, can be arbitrarily fluent while being connected to nothing. That's the goldfish, formalized decades before goldfish were the metaphor.
The repo side is what a stranger can independently recompute, not take our word for. Two live, signed drift receipts: /commit/60d4a3c6b and /commit/2f0ab9b5d — open either, verify the ed25519 signature, and re-run the walk yourself. The sealed breach rate (25.6%, CI [19.6%, 32.6%]) and the two other honest instruments on the same ledger are in Three Breach Rates, One Ledger, including the afternoon our own ledger's seal came back broken and we published that too. And the very first version of this post is its own piece of evidence: the routing misfire in section E was real, we found the actual scoring mechanism responsible (a flat keyword-overlap count with no weight for an explicit, deliberate task declaration), fixed it with an anchor-phrase override, and shipped a regression test — tests/pmu/lens-anchor-phrase-override.test.js — that fails if this exact collision ever comes back. The fix and the guard are in the same commit as this paragraph.
The debate itself: Ben Goertzel and Kai Zen Bickle, AGI Experts: We're About To Lose Control of AI Forever, The Beyond Tomorrow Podcast with Julian Issa (2026-07-02). Three clips carry the specific claims this post responds to: the Omega Claw architecture description at 1:18:56, the Linux/internet decentralization analogy at 0:35:42, and Goertzel's own account of Hyperon's top-level goal system — "it has a few top level goals among which are compassion and care for sentient beings" — at 1:04:42. We're linking to timestamps instead of embedding the player: same reason we link to commit receipts instead of screenshotting them — a link a reader clicks and verifies for themselves beats a frame they're asked to trust, and it keeps this page carrying the same object it always has (our own signed drift panel), not someone else's.
Run npx thetacog-mcp attest-demo and watch a grip verdict — in-domain, out, or unplaced — compute on your own hardware, independent of how capable the model producing the work is. If you're weighing whether to let a system recursively self-improve, the standing conversation on pricing that risk is at thetadriven.com/dinner. And if this post's own live misroute bothered you as much as it should — good. That reliability gap is fixed, guarded, and shipped in this same commit, because a decidable-placement instrument that hides its own misses isn't one either.
![tolerance panel for commit d5658f7 — chore(blog): attach commit tolerance panel as OG image [panel-attached]](/blog/post-panels/2026-07-03-generally-correct-specifically-wrong/d5658f796f0e9dfda8ceafe3e6565a295a033dcc.png)