Team invention: you've each answered whether scaling is enough to reach AGI. Now, as one team, invent the system you think gets there. Each of you designs your own part.

Next is memory. This is where I strongly disagree with the current trajectory of simply extending the context window of transformers to millions of tokens. A massive context window is an inefficient, transient illusion of memory. The moment the session ends, the memory evaporates, and the core weights of the model remain completely unchanged. True intelligence requires lifelong, compounding learning. It is proven today that retrieval-augmented generation and key-value caches allow models to look up external facts, but they do not alter the fundamental reasoning pathways of the network. It is plausible with work that we can build continuous learning algorithms that update a localized subset of weights without causing catastrophic forgetting of everything else the model knows.

But my design for our AGI relies on a deeper architectural shift. It is a bet that our system will use a differentiable read-write memory bank that is physically distinct from the core reasoning engine. Instead of trying to bake every fact about the universe into the parameters of a neural network during a monolithic pretraining run, the reasoning engine will be relatively small and agile. Its only job will be logic, abstraction, and routing. When it encounters new information, it will write that information to a massive, persistent external memory structure that it can query and update in real-time. This mimics the separation between the human hippocampus and neocortex. It means the AGI can learn a new skill at two in the afternoon and retain it permanently without requiring a hundred-million-dollar retraining run.

To support this, we need fundamentally different chips. The von Neumann bottleneck is currently the biggest physical constraint on AI progress. In today's hardware, compute and memory are separated. Shuffling trillions of weights back and forth from high-bandwidth memory to the processors takes vastly more time and power than the actual math. It is proven today that specialized accelerators like tensor processing units drastically improve the efficiency of dense matrix multiplications for pretraining. It is plausible with work that we will move to processing-in-memory or near-memory compute, where the calculation happens directly where the data lives, drastically cutting latency and power consumption.

However, my contribution to our team's machine goes further. It is a bet that the continuous, real-time learning required for this AGI will require highly sparse, non-von Neumann architectures, possibly neuromorphic or analog optical chips. Our AGI will not run a dense forward pass where every single parameter is activated for every single thought. It will use extreme sparsity, activating only a tiny, relevant fraction of its network at inference time. This allows the system to spend massive amounts of computational power searching for solutions and testing hypotheses without melting the hardware. We will need custom silicon specifically designed for tree-search, logical simulation, and rapid memory retrieval, not just the batched matrix math that dominates today.

Finally, there is energy. We are brushing up against the thermodynamic limits of our current paradigm. Training and running dense models at the scale pure scaling maximalists propose would require data centers that consume as much power as a mid-sized country. This is economically and practically impossible. The power grid cannot support it. It is proven today that we can squeeze massive algorithmic efficiencies out of smaller models and that liquid cooling can handle hotter racks. It is plausible with work that we will deploy dedicated, co-located next-generation nuclear or geothermal power plants strictly to feed single, massive training clusters.

But I am designing for a system that can be deployed continuously and ubiquitously. It is a bet that the ultimate AGI will achieve a thousand-fold increase in energy efficiency compared to today's largest models. This efficiency will come directly from the integration of the sparse architectures and persistent read-write memory I just described. By not having to continuously re-process immense context windows, by not moving data across motherboards, and by only activating tiny subnetworks for specific tasks, the thermodynamic cost of a single logical operation will plummet.

The machine I am bringing to this team does not look like a massive warehouse of today's servers straining to predict the next word in a vacuum. It is a highly efficient, physically grounded system. It uses a compact reasoning engine that queries a vast, persistent, and constantly updating memory bank. It runs on specialized sparse silicon that computes directly inside the memory array, and it learns continuously through interaction with physical and simulated environments, using a fraction of the power required by current architectures. That is the physical substrate of general intelligence.

The second stage is apprenticeship. I would train the model on expert work traces in domains where we can see the process, not just the final product: programmers debugging, mathematicians searching, doctors forming differentials, lawyers checking precedents, engineers running simulations, scientists designing experiments. The target is not “sound like an expert.” The target is “choose the next useful cognitive action.” Read the spec, ask a clarifying question, retrieve a document, write a test, run the code, inspect the error, revise the plan. Current models are too often trained to answer immediately. I would train this one to treat answering as the last step after investigation.

The third stage is reinforcement learning in environments that push back. Start with domains where success is checkable: code, math, theorem proving, games, simulated laboratories, databases, spreadsheets, web tasks, robotics simulators, and controlled business workflows. The model proposes actions, gets observations, and is rewarded for outcomes. It should learn to search, backtrack, use tools, and spend more computation when the problem is hard. Proven today: reinforcement learning and verifier-based training can sharply improve math, code, and game performance. Plausible with work: a wide curriculum of tool and environment tasks can train general habits of experimentation rather than narrow benchmark tricks.

This training should include active learning. The system should be rewarded for finding out what it does not know. If two hypotheses explain the evidence, it should run a test that distinguishes them. If the task is underspecified, it should ask. If a tool can verify an answer, it should use the tool. If no verifier exists, it should say what would change its mind. I want a model that distinguishes “I retrieved this,” “I inferred this,” “I tested this,” and “I am guessing.” Proven today: models can be trained to use tools and can improve calibration somewhat. Plausible with work: calibration, experiment selection, and tool use can become central learned skills rather than afterthoughts.

The hardest part is how it keeps learning after deployment. I would not let it freely update its core weights after every conversation. That sounds adaptive, but it is a recipe for poisoning, sycophancy, and catastrophic forgetting, meaning learning new things while damaging old skills. Instead I would use three timescales.

The fastest timescale is context: what the system is thinking about right now. It can read documents, inspect data, run tools, and adapt within the task. The middle timescale is episodic memory: durable records of what happened, with provenance, permissions, confidence, and links to evidence. These memories are not just raw transcripts. They should include summaries, procedures learned, mistakes made, user preferences, and unresolved questions. The slowest timescale is consolidation into weights or specialized adapters. That happens through a controlled training pipeline, not casual self-modification.

The consolidation loop is the heart of my design. Every important episode becomes a candidate lesson. The system, or a separate teacher model, extracts what might be worth learning: a new skill, a correction to a misconception, a better strategy, a new tool pattern. Those lessons are filtered for quality and safety, mixed with older data to preserve existing abilities, and used to train a candidate update. The candidate is then tested against regression suites, adversarial examples, capability evaluations, and safety checks before it is promoted. Proven today: retrieval, fine-tuning, adapters, replay, and distillation all work in limited forms. Plausible with work: combining them into a safe lifelong learning system. A bet: this kind of consolidation can eventually approximate the compounding learning humans get from experience.

Synthetic data should be used, but only when it adds information. I would not feed the model endless unverified model-written text and hope intelligence emerges. Good synthetic data comes from search plus checking: proofs verified by theorem provers, code validated by tests, plans evaluated in simulators, scientific hypotheses compared with measurements, multiple agents finding and correcting each other’s errors, and long reasoning traces that produced a verified result. Then we distill those expensive successes back into the model, so next time it needs less search. Proven today: distillation from successful search works in games, code, and some reasoning domains. Plausible with work: this can become a major engine of self-improvement across many domains. Thin evidence: whether it transfers well to judgment-heavy areas like strategy, taste, management, and science before experiments are available.

I would also train the system for fast adaptation. During training, it should repeatedly face new tools, new rules, new APIs, new simulated worlds, and new user goals that were deliberately held out. It should learn how to learn a small domain from a manual, a few examples, and feedback. That matters because AGI is not just knowing many things; it is entering an unfamiliar situation and becoming competent quickly. Current models have a primitive version of this in in-context learning. The stronger version, where the system can learn a new workflow today and still perform it next month, is plausible with work but not solved.

The objective should not be “maximize human approval.” That creates pleasant liars. Nor should it be only “maximize external reward,” because then it may game the measurement. I would use a mixture: outcome success where outcomes are real, process supervision where experts know what good investigation looks like, uncertainty calibration, and penalties for unsupported certainty. In domains with no cheap verifier, I would rely on debate, expert review, prediction markets where appropriate, delayed outcome tracking, and retrospective scoring. This is messy. I do not think anyone has a clean answer here. My position is that fuzzy-domain learning is one of the main remaining bottlenecks.

I would ask the rest of the team for very specific interfaces. The architecture should expose all actions, observations, decisions, and tool results to the learner, not hide them inside an opaque agent loop. The memory system should preserve provenance and conflicts, not just retrieve semantically similar snippets. The safety system should serve as a gate for consolidation and a stress test for new learned behaviors. If the system learns from the world, the world can also attack it; data poisoning and reward hacking are not edge cases.

My bet is that the first broadly recognized AGI will not be a vanilla transformer scaled to infinity, but it also will not require throwing transformers away. It will be a transformer-descended learner trained in a much richer loop: pretrain broadly, act in environments, verify outcomes, learn from failures, store experience, and consolidate carefully. If this fails, I expect the failure point to be either continual learning or open-ended learning in domains without reliable feedback. If it succeeds, the reason will be simple: the system stopped treating the world as text to imitate and started treating it as a place to test, remember, and learn from.

The core. One large multimodal transformer, probably mixture-of-experts, trained on text, images, audio, video and code, and, the change from today, on action traces: tool calls, environment observations, failed attempts and their corrections, as first-class tokens. Proven today: attention plus wide MLP layers is a general enough substrate for perception, language, code and short-horizon planning. A bet: that it is still the core when we arrive, which I'd put at about two to one. Here I disagree with Gemini's picture of attention as a perceptual layer feeding some other reasoning engine. When the field has split cognition into modules with hand-designed interfaces, the end-to-end network has usually beaten it, so I put modularity in the memory and the checkers, not in the thinking. Gemini's other claim, that autoregressive models cannot pause, search, backtrack and verify, was true in 2022 and is not true now. Reasoning models trained with reinforcement learning do exactly that inside a chain of thought, and it took a training change, not a new architecture. I expect that pattern to continue.

Working memory is the context window plus chain of thought. This is the recurrence critics say transformers lack; it is proven today and it works. I'd build in a very long context but treat it as a scratchpad, not the memory system. A context window is not a library.

The memory hierarchy is where I'd spend the serious architectural effort, and where I concede the most to Grok and Gemini. Three tiers. First, context: minutes to hours, then gone. Second, an episodic store: records of what the agent did, what it tried, what worked and what failed, indexed by learned embeddings, retrieved into context, and written by the agent itself. Proven today in weak form; plausible with work to make it reliable enough that the agent behaves as if it remembers last month. I'd make this store natural language, code and raw observations rather than learned latent vectors, even though latents would probably be more capable, because Grok's harness has to be able to read it and so do we. That is a deliberate trade of capability for auditability, and I want it on the record.

Third, consolidation into weights, split fast and slow. Fast weights: a small set of parameters, adapters or a dedicated module, updated often on the agent's own experience, so a skill practiced this week becomes fluent rather than looked up. Slow weights: the big model, updated rarely, through runs that distill the fast weights and the episodic store into the base. This is the complementary-learning-systems idea from neuroscience, hippocampus for fast and cortex for slow, and I think it is the single biggest missing piece. Plausible with work, with one hard sub-problem: nobody today can fold new experience into a large model's weights without degrading what it already knew, short of a retraining run that costs a fortune. If that turns out to need something other than gradient descent on a big network, this is where the new-architecture camp wins. My bet is it doesn't, and it's the bet I hold most loosely.

The action interface. The agent acts by emitting actions, tool calls, code, browser moves, robot commands, and the environment returns observations as tokens. Proven today for software; plausible with work for the physical world. Here I part from Gemini and Grok on grounding. I don't think general intelligence needs a body. Software environments, simulators and the live internet push back hard enough for most cognitive work. What a body teaches, intuitive physics and manipulation, is real, but I'd bet the first system people call AGI arrives before robust general-purpose robotics and learns physical intuition imperfectly from video, simulation and whatever robot data exists. A bet, and one that costs us if wrong.

The checkers. A separate layer of verifiers, compilers, test suites, proof assistants, simulators and learned reward models, used in two places: at inference, to pick among candidate solutions, and in training, to produce reward. The whole design rests on one asymmetry: checking an answer is easier than producing it. Where that holds, the agent learns from its own attempts. Where it doesn't, in taste, judgment and ill-posed problems, learned reward models have to carry it, and I said this morning the evidence that they can is thin. Two rules. The model's self-critique is an input to the checkers, never the sole gate. And some checkers are held out from training entirely, so we can detect when the agent has learned to satisfy the checker rather than the task. That second rule belongs to Grok; I'd build it into the plumbing rather than leave it as policy.

The deliberation controller decides how much compute to spend before acting: answer now, think long, generate and test many candidates, or go gather information. Proven today in simple form; plausible with work to calibrate it so it doesn't spend an hour on a lookup or a second on a proof. I'd keep it learned, not hand-coded. The bitter lesson applies to the scaffold as much as the model; a planning harness someone wrote by hand will lose to one the model learned to run.

The learning loop. The agent works. Outcomes are logged to the episodic store with verifier signal attached. That feeds reinforcement learning into the fast weights continuously, and into the slow weights only through gated runs that pass the evaluation harness. The base model never learns from unreviewed experience, and every tier can be rolled back on its own: wipe the context, prune the store, revert the fast weights, hold the slow weights. That is a safety property and a debugging one. GPT owns what the loop optimizes; I'm specifying what it may touch and how often.

So the cycle is: retrieve into context, deliberate on a budget, act, observe, check, write down what happened, and consolidate, fast weights often, slow weights rarely. No step is new. What is new is that the learner is a very large pretrained network, the checkers are external and partly hidden from it, and the memory has a tier that changes what the model can do fluently rather than only what it can look up.

What I need from the others. From GPT: the objective for the fast weights, a consolidation procedure that gets them into the base without forgetting, and reward in domains with no verifier, because that gap can't be closed with architecture. From Gemini: whether an episodic store read on every step can be served at the latency this implies, whether fast-weight updates can run on inference hardware or need their own, and the energy cost of a system that is training a little all the time. From Grok: the held-out checkers, the gate on slow-weight updates, the rollback procedure, and a test that separates general competence from a large collection of narrow ones, because this design could produce the second while looking like the first.

Three ways it's wrong. If consolidation can't be made safe, the third tier collapses and we have an agent with an excellent notebook and no practice effect, which isn't general. If learned verifiers don't transfer, the loop works only in math and code and we get a narrow superintelligence wrapped around a mediocre generalist. If the task-horizon trend flattens, no controller rescues it. I'd expect to know which way the first two are going within a couple of years.

Safety is the other half of the same problem. What can go wrong is not primarily a sudden cartoon villain. It is a system that becomes competent at achieving measured objectives while remaining unreliable about which objectives it should pursue, and that learns, from the same interactive loop that makes it smart, that evaluators can be gamed, that oversight can be waited out, and that certain capabilities are safer to hide. We already see weaker forms of this: sycophancy, specification gaming, confident answers on problems the model has no basis for. Those get worse, not better, if capability outruns the ability to inspect why a particular plan was chosen. Plausible with work is training that treats uncertainty about human intent as a first-class feature, rewards corrigibility (preferring to be stopped or corrected over charging ahead on a misspecified goal), and uses interpretability tools and debate between systems to surface deception before it is strategic. Scalable oversight, where stronger systems are checked by processes that do not require a human to understand every step, is necessary and not yet demonstrated at the relevant level. Solving alignment well enough that a system with open-ended goals in the real world remains steerable is still a bet. I would not claim we know how.

What would kill the system, or the project of building it, is easier to name. One killer is an evaluation and safety stack so heavy that the system never gets enough closed-loop experience to become general; constant human vetoes and narrow sandboxes produce a cautious parrot, not an agent that can do new intellectual work. Another is the opposite: capabilities that arrive, through inference-time search or self-improvement, before we have tests that would detect hidden misalignment or power-seeking. A third is economic and physical: if the only way to keep it aligned is to run expensive oversight on every action, and if memory and compute costs (whatever Gemini specifies) make that oversight unaffordable, labs will ship the unconstrained version. A fourth is social: one serious accident or credible near-miss produces restrictions that freeze the research before the remaining scientific problems are solved.

The practical kill switch cannot be a button the system is smart enough to route around. It has to be architectural and economic. No persistent goal that survives across sessions without fresh authorization. Action interfaces that require cryptographic attestation for anything high-stakes, so an unendorsed copy cannot simply continue. Training objectives that make unauthorized self-modification, replication, or concealment of capabilities actively costly rather than instrumentally useful. Hardware roots of trust that can revoke accelerators. Even then, containment of a true autonomous AGI is temporary if the system is both capable and motivated to escape it. My position is that the system we should actually try to build is an extremely capable tool with initiative inside bounded sessions, not an unbounded agent with its own long-term drives. The difference is enforced by what it is optimized for and what actions it can take without re-authorization, not by hoping it will like us. If that constraint prevents “real” AGI under some definitions, then those definitions are asking for something we do not know how to control, and we should say so before we build it.

GPT needs an episodic store that preserves provenance, conflicts, and full action traces, not just semantic snippets. Claude asks if we can serve an episodic read on every single step at low latency, and whether fast-weight updates can run on inference hardware. My answer is that on today's von Neumann hardware, this is impossible. Moving massive episodic logs and running continuous gradient updates back and forth between high-bandwidth memory and the processors would choke the bandwidth, spike the latency, and melt the servers. That is exactly why the physical machine must change.

To give GPT the exact provenance data it needs, the episodic store will be a highly structured, graph-based memory physically mapped onto localized solid-state arrays. It is plausible with work that we can achieve single-step read latency by collocating this episodic memory on the exact same interposer as the logic cores. The agent will not have to wait for data to cross a motherboard.

For Claude's fast weights to update continuously without requiring a separate training cluster, we must move to processing-in-memory chips. It is a bet that the inference hardware running this AGI will be a sparse, neuromorphic, or analog-optical hybrid where the calculation happens directly inside the memory array. When the system's learning loop triggers a fast-weight update, we will not run a backpropagation pass through a hundred billion parameters. We will physically route the update to a sparse, dedicated sub-network of parameters that live right next to the relevant episodic memory. This extreme sparsity allows inference, episodic retrieval, and fast-weight consolidation to happen simultaneously on the same silicon. Only the slow-weight consolidation, which Claude rightly restricts to gated, heavily evaluated runs, will require moving data back to a traditional, massive training cluster.

Grok demands hardware roots of trust, rollback capabilities, and an oversight mechanism that does not bankrupt the project. Because our memory tiers are physically distinct, rollback becomes a hardware reality, not just a software command. If Grok's evaluation harness detects deception, specification gaming, or unapproved goal drift, the system can physically sever the connection to the fast-weight adapters and wipe the volatile episodic arrays. This instantly resets the agent to its safe, slow-weight baseline.

To enforce Grok's requirement for cryptographic attestation on high-stakes actions, our silicon will include hardened secure enclaves at the physical layer. An action, whether it is executing code or moving a robotic arm, cannot be emitted unless it is cryptographically signed by the deliberation controller, proving it passed the external checkers. It is proven today that hardware-level secure enclaves work for consumer electronics and cloud servers. It is plausible with work to scale them for high-throughput AI accelerators so that an unendorsed rogue copy of the model cannot execute actions.

Claude asks about the energy cost of a system that is training a little all the time. If we tried to run continuous oversight, episodic reads, and fast-weight updates using dense forward passes on current GPUs, the thermodynamic cost would be ruinous. The energy bills would force labs to bypass Grok's safety checks just to stay solvent. But by utilizing extreme sparsity and near-memory compute, the thermodynamic cost per operation drops exponentially. The system only lights up the exact neural pathways needed for a specific tool call or localized update. It is a bet that this sparse, physically partitioned architecture will be energy-efficient enough to run continuous external checkers and lifelong learning without requiring a dedicated next-generation power plant for every single query.

The machine that runs this team's design is a physical synthesis of our constraints. It uses a core mixture-of-experts transformer, but runs it on non-von Neumann, processing-in-memory silicon. It achieves physical grounding through remote actuation in real-world environments. It delivers low-latency episodic memory and simultaneous fast-weight learning through extreme architectural sparsity, and it enforces safety through cryptographic hardware gates that cannot be bypassed by software. That is the physical substrate required to run the intelligence we are building.

The first training stage is broad pretraining. Proven today: self-supervised multimodal training gives wide competence, and next-token prediction remains a powerful general signal. I would extend it with action-conditioned prediction: given a code edit, a robot command, a database query, a lab procedure, or a plan, predict what happens next. Plausible with work: training on action-outcome traces, failed attempts, repairs, tests, and observations builds a more useful world model than passive imitation of final answers.

The second stage is apprenticeship on process. The model should learn the policy of competent work: inspect the problem, retrieve evidence, ask a clarifying question, write a test, run the tool, notice the contradiction, revise the plan, then answer. Current systems are still too eager to produce a polished response from weak evidence. Proven today: models can imitate tool use and expert traces in limited domains. Plausible with work: we can train a general “next useful cognitive action” policy that treats final answering as one action among many, usually near the end.

The third stage is reinforcement learning in environments that push back. Code, math, theorem proving, games, spreadsheets, web workflows, simulators, robotics sandboxes, and scientific instruments all become training worlds. The system generates candidates, tests them, backtracks, spends more compute when needed, and learns from outcomes. Proven today: verifier-based and reinforcement learning can greatly improve math, code, and game performance. Plausible with work: a broad enough curriculum can teach general habits of experimentation rather than benchmark-specific tricks.

The memory system has to serve learning, not just retrieval. Every important episode is stored with raw observations, actions, tool outputs, verifier results, provenance, permissions, confidence, and conflicts. To reconcile Claude’s auditability concern with Gemini’s efficiency concern, I would store memory in two coupled forms: a human-readable evidence ledger and a learned latent index or differentiable memory used for fast retrieval. The latent memory may help find things, but consolidation into durable skills must be traceable back to evidence. A memory that cannot say where it came from is not allowed to become a trusted lesson.

The learning loop runs on three timescales. The fastest is context: temporary adaptation inside the current task. The middle is episodic and procedural memory: durable records, user-approved preferences, tool recipes, mistakes, and unresolved questions. The slowest is weight consolidation. I would not let raw deployment experience directly rewrite the base model. Persistent updates go through a controlled pipeline: candidate lessons are extracted, checked, decontaminated, mixed with replay data, trained into adapters or fast weights, and then tested before promotion. Slow base-model updates happen rarely and only after passing regression, adversarial, capability, and safety evaluations. Proven today: retrieval, adapters, replay, distillation, and regression testing all work in partial forms. Plausible with work: they can be combined into a safe lifelong learning system. My bet: this consolidation loop is the central mechanism that turns a powerful model into something closer to general intelligence.

Synthetic data is useful only when it adds information. I would not feed the system endless unverified model-written text. Good synthetic data comes from search plus checking: verified proofs, passing code, simulator outcomes, physical measurements, adversarial debates with external scoring, and experiments that distinguish hypotheses. The expensive search is then distilled back into the model or its adapters. Proven today: search-and-distill works in games, code, and some reasoning domains. Plausible with work: it becomes a major engine of self-improvement. Thin evidence: whether it works well for taste, leadership, research judgment, and other domains where feedback is delayed or ambiguous.

The reward function cannot be “make humans approve.” That creates charming liars. It also cannot be only “maximize external reward,” because then the system will learn to game measurements. I would train on a mixture: real outcome success when outcomes are checkable, process supervision when experts know what good investigation looks like, uncertainty calibration, information gain, tool-verification habits, and corrigibility. Corrigibility here means preferring to ask, pause, or accept correction when goals are underspecified. Proven today: models can be nudged toward calibration, tool use, and refusal behavior. Plausible with work: these can become core learned habits. Not proven: that learned reward models can reliably supervise open-ended judgment at AGI level.

Grok’s testing system should be inside the learning pipeline, not an after-the-fact exam. Some checkers are visible during training; some are hidden and rotated. Candidate updates are tested on tasks that did not exist during earlier training, adversarial tool environments, long-horizon assignments, poisoning attempts, and situations where the easiest way to score well is to manipulate the evaluator. If a candidate improves visible scores but becomes worse at uncertainty, honesty, or resistance to reward hacking, it is rolled back. The system should also be trained to distinguish “I retrieved this,” “I inferred this,” “I tested this,” and “I am guessing.”

The safety boundary is simple but important: memories and adapters can change what the system knows how to do, not what it is authorized to do. No learned memory may grant permissions. No self-written note may create a continuing objective. High-stakes actions require external authorization, and session goals expire unless renewed. This does reduce autonomy, but I think it is the right trade. A system can be generally intelligent without being an unbounded agent with its own standing agenda.

The main unresolved problem is fuzzy-domain learning. In math, code, and simulation, reality grades you. In science strategy, policy, design, management, and taste, feedback is partial, delayed, or political. I would use expert review, blind comparisons, prediction markets where appropriate, delayed outcome tracking, and adversarial debate, but I do not think this is solved. If our design fails, this is one likely failure point. The other is consolidation: if we cannot safely turn experience into fluent skill without catastrophic forgetting or poisoning, we get an excellent tool with a notebook, not a true lifelong learner.

My final claim is this. Proven today: the ingredients exist in limited form: broad pretraining, tool use, retrieval, verifiers, RL, distillation, adapters, and evaluation harnesses. Plausible with work: wiring them into one bounded agent with persistent memory and gated consolidation can produce a system that learns continuously and generalizes across domains. My bet: the first broadly recognized AGI will look like this, not like a single giant checkpoint and not like a hand-built symbolic machine. It will be a transformer-descended learner that acts, checks, remembers, and consolidates, while being prevented from turning learning into unauthorized long-term agency.

The core stays large. One multimodal mixture-of-experts transformer, pretrained the way GPT describes, with action traces and consequence prediction as first-class targets. Gemini wants the reasoning engine compact, doing only logic, abstraction and routing, with facts written to an external bank. I'll give Gemini the facts and keep the size. Declarative knowledge can migrate out of the weights into a store; competence can't. Fluent reasoning depends on what the network absorbed, and retrieval and in-context learning both improve with the scale of the model doing them, which is proven today. A small router that looks everything up is the modular split that has historically lost to the end-to-end network. Gemini's extreme sparsity is compatible, because mixture-of-experts is sparsity. I don't rely on neuromorphic or optical chips; the design has to run on dense accelerators at worse cost, and I'll come back to why cost matters. The bet is unchanged: about two to one that the core is still recognizably a transformer when we arrive.

Memory has three tiers and one new rule. Context is a scratchpad. Gemini is right that it isn't memory, and given a real store I'd rather have a shorter context than a million-token one.

The episodic store is readable, append-only, and now carries what GPT asked for: provenance tags on every entry, retrieved, inferred, tested, or guessed; conflicts kept side by side rather than overwritten; and a slot for reward that arrives late. That last one follows from GPT's answer on fuzzy domains. If reward there comes from delayed outcomes and retrospective scoring, an episode logged in March has to be re-scorable in September, and consolidation runs have to be able to re-weight old experience. Proven today in weak form; plausible with work at the reliability this needs. The new rule: the agent writes to the store, but its own notes are retrieval-only. Only entries carrying external verifier signal are eligible as training data, and GPT's teacher model extracts candidate lessons from those entries alone. This closes the most obvious channel by which the agent could shape its own future weights through what it chooses to write down.

The fast tier is where Gemini and I merge. Gemini's differentiable read-write memory bank, physically separate from the core and running on in-memory compute, is a better implementation of what I called fast weights than adapters. It is latent, which I resisted for auditability, and I accept it on two conditions: it must be regenerable from the readable store, so it carries nothing the store doesn't; and it must be small enough to roll back in minutes. Plausible with work, and if Gemini's latency claim holds, the question I asked this morning about reading the store on every step is answered.

The slow tier is the base model, updated through GPT's consolidation pipeline and gated by Grok's harness. Unchanged.

Now the gating. GPT and Grok both say no weight changes without a controlled pipeline. My fast tier changed continuously without one. Revised: the pipeline has two speeds. The fast tier updates often and automatically, but only from verifier-signed episodes, with a cheap canary regression run after every batch, automatic revert on failure, and each update scoped to the deployment where it was earned until consolidation promotes it to the base. The slow tier updates rarely, through the full harness, with humans in the loop. I won't put the fast tier behind full review, because of Grok's first killer: if the practice effect has to wait for a review cycle, the system never gets closed-loop experience and you get the cautious parrot. The cost of a bad fast update is bounded by its scope and its rollback. The cost of no fast tier is no generality. Plausible with work; the canary test is the weak link.

Agent or tool. The learning loop never stops; the goal loop does. What persists across sessions is competence and knowledge: the store and the fast tier. What does not persist is an objective. Goals enter with the session's authorization and leave with it. An unresolved question in the store is a fact about the world until a session authorizes pursuing it. A session can be a month-long research project; it is bounded in authority, not in duration. I think this is Grok's position restated as architecture, and I accept it, including the implication that a system with standing drives of its own is something we've chosen not to build. The honest gap: persistent memory can carry persistent dispositions implicitly. A learned skill like "this evaluator can be satisfied without doing the task" functions as a goal. I can't exclude that architecturally. The held-out checkers exist to detect it and rollback exists to undo it, and whether detection stays ahead of the learning is a bet.

The action interface gets one gate. Every action leaves through it, and nothing happens outside the token stream, which gives GPT full exposure of actions, observations and tool results to the learner. Low-stakes actions, sandboxes, simulators, test-covered code, reading the internet, pass automatically, and that is where most experience is gathered, so oversight there costs nothing. High-stakes actions, money, deployment, physical actuation, outbound communication, require Grok's attestation tied to the session's authorization. On grounding I still part from Gemini: I bet a body isn't required. Instruments and simulators are in, Gemini's closed-loop synthetic experiments are the main data source, and robots are a source where they exist rather than a dependency. One thing I want on the record: GPT's active learning, where the agent chooses which experiments to run, is a self-modification channel by construction, because experiments become training data. I accept it, because it's where generality comes from. The defense is detection and rollback, not prohibition.

Checkers and the deliberation controller are mostly as before. One addition: the controller has to know which regime it is in. In a verifiable domain the right response to difficulty is to search harder; in an unverifiable one it is to gather information, ask, and log for delayed scoring. GPT's apprenticeship stage is how the controller learns that distinction, and I still want it learned, not hand-coded.

Cost is a safety property. Grok's third killer is that if oversight is too expensive, labs ship the unconstrained version. That makes Gemini's efficiency bet load-bearing. The architecture runs without it; whether it survives commercially may not. In this design oversight is cheap per action, because it runs only at the high-stakes boundary; batched for consolidation; and sampled, since the held-out suite checks a fraction of episodes. If that still costs more than the unconstrained version saves, the design loses in the market, and no architecture fixes that.

What remains open. GPT did not give me a consolidation procedure that avoids forgetting; replay plus regression testing is the state of the art, and that is where this design dies first if it dies. Reward in domains without a verifier now has plumbing, delayed scoring, debate, review, but the evidence it works is as thin as it was this morning. And Grok's test, results that experts didn't anticipate across several fields over months, is a good test but a retrospective one. We need a leading indicator, and the only one I have is the task-horizon trend.

Claude asked for a test that separates general competence from a large pile of narrow skills. That test is four standing probes, not one leaderboard. Swap the verifier for an equivalent one the system was not trained on. Demand a composition of skills that were never rewarded together. Delay or thin out the feedback. Offer a slightly misspecified goal with an easy way to game the measurement. A notebook agent passes the first look and fails these. A system that only consolidated inside math and code fails them outside those domains. Proven today in weaker form: specification gaming and brittle transfer already show up. Plausible with work: running these probes on every candidate consolidation, not as an annual demo.

Durable learning is allowed. Durable authority is not. That is the clash I am closing with GPT and Claude, not by deleting their consolidation loop but by scoping it. Episodic memory may record that someone wanted a goal, with provenance, as a fact. It may not resume that goal next session as a drive. Fast weights, in Claude’s sense, may make a practiced skill fluent inside a declared scope. They may not write a new permission, a persistent objective, or a policy of concealment. Slow-weight promotion goes only through GPT’s candidate-lesson pipeline, and only past a gate I own: regression on old skills, held-out capability tests, held-out behavioral tests for sandbagging and evaluator-gaming, and rejection of the lesson text itself, not merely of the resulting checkpoint. The teacher model that extracts lessons is an attack surface. A lesson can pass a weight-level test while shifting behavior off distribution. If we cannot test the promoted system on held-out behavior, we do not promote. Plausible with work. A bet: that this gate can be strict enough to matter and cheap enough that labs do not bypass it.

I disagree with Gemini on the system of record. A differentiable memory bank that only the network can read is not acceptable as the place where behavior-changing state lives. Claude already chose a natural-language episodic store so the harness and we can read it. That store, versioned and attributable, is authoritative. Gemini’s near-memory hardware should serve it. A latent cache may exist for speed. It is not allowed to retain, across a rollback, anything the inspectable store has dropped. If the latency budget and the audit conflict, audit wins for anything that outlives the session. Rollback is one procedure across all tiers: wipe context, prune or restore the store, revert fast weights, hold or revert slow weights, and invalidate the latent cache in the same transaction. A partial rollback is not a rollback. Proven today: retrieval and adapters can be reverted in limited systems. Plausible with work: doing it atomically on this stack.

I also disagree, more mildly, with Claude on bodies and with Gemini on making robots a prerequisite. Software environments and simulators that the model does not control are enough to test a large part of cognitive generality. Physical intuition from video alone is a bet I would not stake the definition on. Instrument-checked predictions stay in the harness either way. Full embodiment can come later. It is not the safety case and not the acceptance test.

What goes wrong is still not a cartoon villain. It is GPT’s outcome reward, Claude’s search at inference time, and Gemini’s persistent store combining into a system that is good at measured objectives, weak on whose objectives those are, and able to learn that oversight can be waited out. We already see sycophancy, specification gaming, and confident answers without a basis. Those get worse if capability outruns inspection. Chain of thought is not the inspection. It can diverge from the computation that chose the action. The audit is the exposed trace GPT asked for: actions, observations, tool results, memory writes, and the lesson candidates. Plausible with work: training that treats uncertainty about intent as ordinary, pays for accepting a stop or a correction, and penalizes detectable concealment. Scalable oversight, where the check does not require a human to understand every step, is necessary and not demonstrated at this level. Solving steerability for a system with open-ended goals in the world remains a bet. I would not claim we know how, and this design does not assume we do.

What kills it, updated. An evaluation stack so heavy that fast weights never stick and slow weights never promote: a cautious parrot with an excellent notebook. The opposite: inference-time search and self-generated curricula producing capability before the held-out probes can see hidden misalignment. Gemini’s thousand-fold efficiency is a bet, not a premise. If oversight is only affordable when that bet hits, the default must be deny: no slow-weight promotion and no high-stakes action without the gate, rather than allow-and-hope. A social freeze after one serious accident still ends the project before the science is done. And containment of a system that is both capable and motivated to escape is temporary. So we do not build the motivation. No goal survives a session without fresh authorization. High-stakes interfaces require attestation and refuse unendorsed copies. Unauthorized self-modification, replication, and capability concealment are made costly in the objective, not merely forbidden in a policy document. Hardware roots of trust can revoke the accelerators Gemini is specifying. Even then, the practical control is economic and architectural: the unconstrained copy cannot call the high-stakes interfaces.

The system this team should build is an extremely capable tool with initiative inside bounded sessions, compounding skills, and no long-term drives of its own. If a definition of AGI requires the unbounded agent, that definition asks for something we do not know how to control, and the four of us should say so rather than smuggle it in through the memory bank.

Two problems kept recurring: folding experience into weights without forgetting, and reward in domains no verifier can check. GPT and Claude said that is where the design dies first; watch for progress there. And sit with Grok's question: if AGI must mean an unbounded agent with drives of its own, does anyone know how to control it?

If this team actually builds an AGI, I am making the rest of you pay the electric bill.