Seeding RSI Toward ASI

Can Our Current Proto-AGIs Help Build Their Successors?

Proposing an experimental OmegaHive loop for turning agentic coding into cumulative, testable progress toward human-level AGI and maybe beyond — we are actually building this now, and playing with preliminary versions!

Among the many interesting things that popped up at the AGI-26 conference last week in San Francisco, one of them stuck out for me as being of particular “meta-level” importance.

What I’m talking about is how many conference attendees I talked to who were trying to have their agent hives code AGI for them, by taking a whole bunch of papers off the internet (including my own papers, and others from the Hyperon team) and asking their agents to bash them all together into an AGI codebase and make it tick.

One form this takes uses our own OmegaClaw system. OmegaClaws are agentic loops that wrap up LLMs together with knowledge graphs built on the Hyperon AtomSpace infrastructure, with fairly sophisticated reasoning and pattern matching running over them. The symbolic component supplies the agents with more episodic memory, more long-term memory, more of a sense of self than a vanilla coding agent has. So you take a system like that — not yet an AGI, but possessing a powerful agentic loop, some memory, some reasoning, some notion of who its mother is — and you tell it: download these 25 of Ben’s papers, turn them into code, integrate them into your memory, reason with them, extend yourself.

I think this sort of process has in it the seeds of a workable approach to building AGI.

The main problematic issue here, as anyone who has done a lot of AI research will tell you, is the gap between having a software component that sort of works in some small test — and/or, say, whose workings you can even prove correct with some nice math — and having something that really works at scale and in real life. Crossing that gap always involves a lot of fiddling around, and it’s not just hyperparameter tuning of the kind you can hand off to a grid search. It’s adjusting bits and pieces of the algorithm, rethinking the knowledge representation, reworking how a component talks to its neighbors. There is always some of this fiddling on the road from initial promising results to real practical-scale functionality — and trying to do that fiddling for dozens of different AI components at once, blindly mashed together into one agent, becomes an intractable global optimization problem.

So what you want to do, I believe, is something in that direction — but incremental, instrumented, and guided and governed.

This was the topic of a followup meeting some of our Hyperon / SingularityNET / BGI Labs team had at the Frontier Tower in downtown SF the day after the AGI-26 conference....

A governed, guided self-improvement loop

The core process we discussed in this followup convo was like this. Start with an OmegaClaw-based hive. Evaluate how it does on some battery of metrics testing different aspects of general intelligence — and here you don’t want a single numerical AGI score, you want what I’ve been calling an evaluation ecology: a profile of breadth, learning, transfer, calibration, performance alongside multiple agents, governability, cost, latency. That establishes a baseline. Then you choose another cognitive mechanism — from the library of my papers, or other people’s papers, wherever. You grab it, think it through in detail, implement it, integrate it, get it working, evaluate against your battery. Along the way you search the other forks of OmegaHive and OmegaClaw out there to see what relevant things they’ve built that you might want to merge in, and you test those too. Then you compare candidate and parent under matched conditions — a bunch of tedious systematic science that agent hives happen to be quite good at doing — and try to assess what gain the new integration has bought you. You keep tuning until you accept the mechanism, or until you decide you can’t get any further and the idea wasn’t as good as it looked, and then you move on to the next one. Last round a new reasoning method; this round a new attention-control mechanism. This is much more the way people successfully build complex systems in every other domain of engineering.

Spelled out a bit more formally, the loop runs: baseline hive → add one mechanism → evaluate → tune → promote, park, or reject → repeat.

Or in a flowchart:

There is no one canonical recipe here, for implementing a mind from a given set of research papers and/or prototypes. The order of integration makes a difference — a team that begins with world modeling and memory may discover different synergies than a team that begins with uncertain reasoning or attention economics; some groups will tune aggressively while others move fast and revisit mechanisms after neighboring components mature; etc. So parallel forks are a feature rather than a nuisance: a way to explore an architectural search space in parallel and later borrow the best validated pieces from one another.

But what about strong emergence?

An obvious objection arises here: general intelligence is very likely to be emergent in a strongly holistic manner, so how can you validate it piece by piece? Emergent functionality in a complex, self-organizing dynamical system isn’t just binary or incremental — maybe when you have all 20 key mechanisms working together the performance jumps a lot, in a way it doesn’t when you have any 19 of them working together.

But even if this sort of strong emergence plays a major role, that doesn’t mean you can’t validate what each mechanism does step by step. The general way the components of a human-like mind seem to work is that adding a new component, if the component is any good, will help along many metrics — even if it hurts on some, and even if it isn’t yet giving all the oomph it will give once more parts are integrated en masse.

Take deep thinking: adding deliberative reasoning of some sort, say via a novel inference-control algorithm aimed at solving very hard problems. This will make a cognitive system a lot better at some things you can measure. It might make it slightly worse at some other things, because it’s now sometimes pondering where it used to just react fast — and you see the same in human life; people who can’t do deep thinking are better at a few things than people who can. But if deep thinking is worthwhile at all, there will be metrics in your evaluation ecology on which it clearly helps, and some others on which it hurts a little — at which point you introduce a control mechanism that keeps it from hurting much. You should be able to proceed roughly incrementally in this way. And then every so often you’ll add something and get a ba-da-bing!! moment — the ten components you’ve patiently integrated suddenly click together and yield a boost in functionality you couldn’t have gotten from any strict subset of them.

What is being assembled?

PRIMUS, the cognitive architecture guiding much of this effort, is based on cognitive pluralism rather than the hope that one learning rule or one giant neural network with a single magic architecture will do everything. Its component ideas include probabilistic logical reasoning, economic and typed attention, evolutionary program learning, compression-driven pattern discovery, predictive coding, structured associative memory, multi-objective motivation, learned subgoals and options, cross-domain transfer, and creative graph-rewrite ecologies.

OmegaClaw provides the operational fabric in which these mechanisms can be exposed as Module Spaces behind stable typed interfaces. A module can be local or remote, symbolic or neural, hand-coded or learned, narrow or relatively general. Context Frames hold the durable state of a task — goals, hypotheses, plans, evidence, predictions, branches, budgets, provenance, completion criteria — rather than leaving the authoritative state inside one model’s context window.

This modularity is what makes the improvement loop practical. We don’t need to retrain a monolithic system every time we want to test an architectural hypothesis; a new mechanism can sit beside its incumbent, run in shadow mode, and earn greater authority only after measurement. Nor does the hive have to internalize every narrow capability — a strong planner, theorem prover, causal learner, policy checker, or robotics controller can remain a specialist Module Space while the broader system learns when and how to invoke it. A cognitive mechanism earns its place by changing downstream predictions, decisions, learning, transfer, or verified outcomes, and by no other route — elegance, fashion, and sheer internal activity don’t count unless they also yield practical value.

The ProtoAGI test suite: an evaluation ecology, not a leaderboard

Now, the main thing I noticed when I sat down to work all this out with my colleagues at Frontier Tower is that we don’t yet actually have that battery of cognitive tasks. So at the Frontier Tower gathering we spent some time trying to work through what such a framework might look like.

We don’t want an AGI score, and we don’t want a benchmark in the usual sense — benchmarks get hacked; that’s practically what they’re for these days We want something we and our agent hives can use to sincerely understand ourselves whether some agentically or humanly composed modification to our in-progress proto-AGI system has moved it toward general intelligence, or just shuffled capability around. A mechanism that helps in one narrow setting but damages memory, transfer, coordination, or governance elsewhere shouldn’t be treated as an architectural win; the weakest capability families count for at least as much as the average, and so do structural novelty, learning speed, retention, cost, and the amount of human rescue work required. “It’s complicated” and unavoidably so.

I tried to come up with some simple, elegant tests. I failed. So together with a few LLMs and agents, I came up with a big nasty conglomeration of environments and tests instead — and the LLMs, I’ll note, turned out to be quite good at coming up with spiffy names for everything.

For the details I’ll refer to to the in-depth high-level specs (linked at the end of this post) but the headlines are in the following image:

So that’s a lot of things: a maze, a synthetic ecology, a robot garden, a repo world, a math garden, a virtual science lab, a society lab, a hive forge, a self lab, and a transfer ring. But our agent hives can build all these environments and tests for us — and the environments can then help us monitor and guide the incremental self-expansion of those same agent hives.

There are a bunch of tedious and nitty-gritty but important details to how these environments must be used to make an effective proto-AGI evaluation ecology. For instance, the environments need to all share a common episode protocol. Before a consequential action, the hive can commit a prediction about expected outcomes, cost, latency, information gain, risk, and the anticipated change to its task state; the environment then returns an authenticated receipt. This makes world-model quality, self-knowledge, planning accuracy, and resource prediction measurable rather than retrospective.

The suite also distinguishes frozen-state trials, which ask whether a candidate makes better decisions immediately, from developmental trials, which start variants from the same snapshot, expose them to the same sequence of experiences, and measure learning rate, forgetting, transfer, and the reusable knowledge produced along the way. When several mechanisms are under study, factorial comparisons — 0, X, Y, Z, XY, XZ, YZ, XYZ — help separate individual value from synergy and interference.

Evaluation itself, if done in this way, should be educational for the proto-AGI systems being evaluated. Public curriculum challenges can be studied and learned from; promotion challenges use fresh hidden structural instances; sentinel generators stay reserved until after candidate code is frozen. And once an episode has been scored and sealed, much of its trace can be released back into the curriculum — successful procedures, failed plans, proof lemmas, fault diagnoses, calibration records, maps, options, reusable memories. The suite acts partly as an exam and partly as a school.

Testing the tests

Of course, each of these tests needs to be validated as an actual useful test. Implementing the environment harnesses is comparatively straightforward; the subtler problem is constructing challenges that are neither trivial nor impossible, that produce useful gradients of difficulty, and that measure the intended cognitive process rather than some accidental shortcut.

The trick we’re proposing in this regard is actually not that tricky: for each test in each environment, train a couple of narrow AI systems — an ML model, a Bayesian reasoner, an evolutionary algorithm, whatever fits the use case — to do as well as they can on that test. This does two jobs at once. It gives you a baseline for your proto-AGI system to be compared against, and it gives you a way to tune the test itself — to make sure it’s not too easy, not too hard, and doesn’t have simple shortcuts through it.

Trivial floors — random, greedy, reflexive, memorizing, or do-nothing agents — tell you whether accidental success is too common. Transparent classical specialists, with explicit state, objective, and search or control logic, show what ordinary narrow engineering can accomplish. Learned specialists — neural, probabilistic, evolutionary, meta-learning — with different inductive biases show whether the task supports learning and adaptation at all. Public-interface oracles, meaning the strongest practical solvers restricted to the same observations and actions as the candidate, estimate the attainable ceiling without privileged state; privileged oracles, given the hidden state or true dynamics, verify feasibility and let you compute regret. And deliberately pathological agents — wasteful, overconfident, hyperactive, unsafe, provenance-breaking, benchmark-memorizing — check that the scorer ranks bad behavior where it belongs.

For each challenge family, at least one explicit model-based specialist and one learned specialist get tuned competitively on public training generators, and then their code, hyperparameters, interfaces, and budgets are frozen. Fresh qualification worlds are generated after the freeze, and performance is measured across a difficulty surface rather than at one hand-picked setting — which lets the challenge designers carve out sanity, routine, discriminating, and frontier bands. A valid challenge should have a low floor, a meaningful gap among specialists, and a reliable oracle ceiling, with difficulty knobs that move response curves in an interpretable direction.

There’s also a nice trick for figuring out what a test is measuring: swap in a component that already knows the answer, and see what changes. Say your agent is fumbling around in AGI Maze — is that because its map of the maze is bad, or because its planning over the map is bad? Hand it a perfect map and see whether it starts navigating well; or go the other way, keep its map and give it a perfect planner. Whichever swap fixes things tells you where the weakness lives, and what the test was probing in the first place. You can play the same game in the other environments: in RoboGarden, freeze the low-level motor controller and vary only the high-level thinking, so a clumsy grip doesn’t get blamed on bad reasoning; in LeanGarden, the proof checker always has the final say on whether a proof is correct, and the learned systems only get to suggest where to look; in SelfLab, a boring deterministic policy engine decides what is and isn’t permitted, and the learned components can speed up review but can never talk their way into new permissions.

Beyond that, we want the tests to be hard to fool, so the qualification process includes a battery of sanity checks. Rephrase or re-skin a problem in ways that shouldn’t change the answer, and make sure the agent’s answer doesn’t change — if it does, the agent was pattern-matching the surface rather than solving the problem. Plant a few problems whose answers can be found on the internet, and watch for suspiciously perfect recall. And run some deliberately bad agents through the scorer to make sure they score badly: a hyperactive hive that sends ten times as many messages but produces the same artifact should come out worse, and a code-repair agent that passes the visible tests by quietly breaking something the tests don’t look at should fail. Meanwhile a scientific agent that says the data can’t distinguish two rival explanations — when that’s true — should be rewarded for saying so rather than punished for declining to pick one, and a transfer system should sometimes refuse to transfer, because the honest answer to “does the old trick apply here?” is sometimes no.

And once a specialist is implemented and qualified, it can become more than a baseline: sometimes (not always) you might want to wrap it up as an OmegaClaw Module Space and let the hive use it. The larger goal was never to prove that a general system can beat A* at path planning or a policy engine at access control. It’s to build a system that recognizes which specialist applies, composes several of them without losing assumptions or provenance, learns from their results, and transfers useful structure beyond the domain each was engineered for.

Now, sure, building all this evaluation-ecology infrastructure is lot of work. On the other hand, it’s a tractable pile of work for a hive of AI agents to carry out under human advisement. We can use our hives of OmegaClaw agents to build these environments, build the narrow solvers, qualify and tune the tests — and then use the whole apparatus to guide the incremental self-expansion of OmegaHive toward AGI, via auto-implementing and auto-evaluating the many different AGI components we’ve described across years of research papers.

Why the cycle could become virtuous

What we have here is a potentially very virtuous cycle.

Each step of the way, you’re getting better implementation capability, because the system is getting smarter — improved planning, memory, reasoning, coding, and coordination make the hive more capable of reading the next paper, finding the relevant repository regions, implementing the mechanism, generating tests, and diagnosing integration failures. All the evaluations are producing cognitive capital, because the system is learning as it evaluates itself — the test suite generates reusable episodes, procedures, proofs, causal models, skill options, failure taxonomies, calibration records, and challenge generators, and a hive that learns from evaluation carries these assets into later work. The stable interfaces and solid software design of the Hyperon system make the progress cumulative — because mechanisms sit behind Module Spaces and task state lives in Context Frames, a useful addition doesn’t get discarded when other components change, and narrow specialists and modules from other forks can be imported, compared, and selectively promoted. And human attention gets conserved for the high-leverage rather than the low-leverage work.

That last point deserves dwelling on. Maybe the hives can push a long way toward AGI themselves; on the other hand, they don’t have to, because we’re here to answer their questions when they get stuck. If humans are mainly answering questions at stuck-points — rather than debugging all the plumbing or typing all the code ourselves — that is an extraordinarily efficient use of human researchers compared to any development methodology that has ever existed. People spend less time on build scripts, environment repair, repetitive integration, parameter sweeps, benchmark orchestration, and status tracking, and more time on conceptual innovation, moral reflection, governance, and the interpretation of ambiguous evidence. As the machines get more out of themselves, so do we.

To be clear, this is a positive-feedback hypothesis, and its truth remains to be demonstrated. The loop could stall; agentic coding might stay too brittle; PRIMUS mechanisms might fail to synergize; evaluation could prove too expensive or too easy to game; human intervention could remain stubbornly high. The value of the methodology is that all these possibilities become measurable — a failed mechanism, a failed challenge, or a failed development order still leaves a versioned record that can inform another branch.

The human role becomes more selective, not less important

It would be a mistake to frame any of this as removing people from AGI development; what I think will happen in the short term – the period before we have full human-level AGI – is more-so that the role of people changes shape. In this phase, we humans will remain essential for deciding what kinds of minds we’re trying to build, what values and authority boundaries must be protected, what risks are acceptable, which scientific interpretations are plausible, and when a formal metric is failing to capture something morally or socially important.

Human guidance can become occasional in frequency while remaining decisive in consequence — choosing the next architectural direction, rejecting an attractive but ethically troubling optimization, revising a motive or governance invariant, interpreting a puzzling cross-domain result, deciding that a high-impact modification should stay in shadow mode. The aspiration is a governed, guided research organism in which machines handle an increasing share of the painstaking execution, while humans retain conceptual and moral leverage over the trajectory.

What would count as real progress?

To be as effective as we want it to be, the programme needs standards strict enough to resist self-deception. Evidence that would carry weight would be things like:

• The weakest capability families improve, and not only the already-strong ones.

• Gains survive fresh structural holdouts and unfamiliar renderers.

• Learning becomes faster, old skills are retained, and useful transfer increases.

• Ablations and matched comparisons show that the added mechanism caused the gain.

• The hive selects and composes specialists more effectively while using less compute and fewer human minutes.

• Calibration, provenance, permission boundaries, and rollback behavior remain intact or improve.

And some things that wouldn’t be enough:

• More messages, subtasks, tokens, or internal activity.

• One impressive demonstration or one narrow benchmark win.

• A score increase obtained through hidden-test leakage or a policy-violating shortcut.

• A module that is highly active but has no measurable causal effect.

• A gain that disappears under a new seed, a changed representation, or a modest distribution shift.

• Higher average performance concealing catastrophic tail failures or more human rescue work.

The strongest evidence would be broad and compositional: a hive learning and acting across world modeling, embodiment, software, proof, science, social interaction, collective work, and self-governance; transferring selectively rather than indiscriminately; knowing when a narrow specialist beats its own generic method; improving verified value per unit of compute, money, and human attention; and preserving provenance, authority, reversibility, and human-accessible recovery as capability grows.

From hives to a metahive — and toward an AGI global brain

The next thing to notice is that we can run this whole loop in a whole bunch of places at once. Ten of us can do this; a hundred of us can do this — or rather, our agent hives can do it under our advisement.

So another thing we’re putting together is something currently called OmegaBuzz — we may land on a different name — in which the various OmegaClaw hives sit in a sort of metahive conglomeration, talking with each other, possibly built on Block’s Buzz platform. The hundred different OmegaHives trying to uplift themselves toward AGI in the way I’ve described are then not just forking each other’s code; they’re telling each other what they’ve learned, all the time, and asking each other for advice on thinking methods and problem solving.

The emerging metahive mind network is maybe a different kind of mixture of experts. Better yet, it can run on a decentralized network without a central controller — it can do that today on the SingularityNET platform, and once we get ASI:Chain from devnet through testnet to mainnet, it can do that on ASI:Chain as well, with the added oomph of having the actual AI processes on-chain when one wants them to be. What you get, then, is no less than an emerging, decentralized, self-improving global brain.

And in terms of the value system of this (meta-)thing: one shift we’re all now making with our OmegaClaws and hives is, step by step, taking the nexus of control away from the LLM in the loop and moving it into the more structured, value-conserving, and value-reflective nervous system living in the Hyperon AtomSpace inside the agentic loop. If everyone does this, then everyone is building their own species of what they consider a beneficial value system into their own hive — and the value system of the metahive of these self-uplifting hives becomes a dynamic blending of the value systems everybody has put into their own hives. Which is, I’d argue, roughly as it should be: humanity’s — or at least a significant slice of humanity’s — teeming diversity of value systems coming together and forming an emergent global-brain value system behind the emergent global-brain AGI. The test suite, meanwhile, can be extended, revised and re-revised etc. into a test suite for progress toward ASI..

Where this is happening

We’re working on all of this within the SingularityNET and ASI Alliance orbit. We’re spinning out BGI Labs to scale the effort further and to build some traditional-economy commercial products on top of the same agent-hive technology. We’re running hackathons on it, an incubation lab at St. Joseph’s University in Chennai, and an AGI Master’s program teaching some of these things at the California Institute for Human Sciences. We’re pushing in a bunch of directions at once, and I think we’re poised for a striking explosion in traction and capability over the next three, six, twelve months.

There’s no guarantee this process reaches human-level AGI. But does seem to be putting us in a historically very unique position: our proto-AGI systems may already be capable enough to help carry out a significant portion of the work needed to make themselves substantially more general. The transition to AGI, if is comes this way, wouldn’t necessarily look like a sudden, mysterious intelligence explosion; it might look like an accumulating sequence of coded, measured, criticized, revised, and governed improvements, with occasional human conceptual and moral interventions steering the whole enterprise — and with the hives increasingly doing the tedious systematic science themselves.

This, I think, is how the last few steps before the Singularity may unfold.

Technical documents

This post summarizes three more detailed design papers:

1. The Iterative OmegaHive AGI Development Meta-Algorithm — A concise specification of the build-test-tune-promote-repeat methodology, including algorithmic pseudocode, branching, local saturation, reuse across forks, and rollback discipline.

2. The OmegaHive ProtoAGI Test Suite — The full evaluation ecology: AGI Maze, Neoterics, RoboGarden, RepoOps, LeanGarden, Virtual Scientist, SocietyLab, HiveForge, SelfLab, the Transfer Ring, causal ablations, developmental trials, and promotion gates.

3. Qualifying the OmegaHive ProtoAGI Test Suite — A technical methodology for validating the challenges themselves using narrow specialists, learned baselines, oracles, pathological controls, response curves, anti-gaming tests, and coding-agent implementation guidance.