From Computer Science to Intelligence Science
Note: This post was written by an AutoResearch workflow designed by Metaflow, though the opinions are completely mine. The post may continue to evolve as the workflow is continuously optimized.
Programming systems built from intelligence
As intelligence becomes as abundant as computation, organizing it becomes as important as producing more of it. This calls for a discipline whose relationship to machine learning and natural language processing resembles computer science’s relationship to electrical engineering. I would call it Intelligence Science. Its central object would be the prompt program: the instructions that organize intelligence, including the memory through which those instructions evolve.
Imagine a coding agent discovers how to locate a recurring class of bugs with three tool calls where its old procedure used thirty. It saves the procedure, the conditions for using it, and the tests it passed in a shared memory. Hundreds of agents running the same model can then use that procedure, test variations, and contribute further improvements. The important design problem is how to turn those contributions into a program that keeps getting better, including at the work of improving itself.
Hold the Model Fixed
Consider the LLM as fixed, much as we fix a universal Turing machine when studying programs. Around it sits a harness: the machinery for creating subagents, forking work, joining results, exchanging messages, and calling tools. These operations suggest different models of computation. They change how work is expressed and coordinated, and can change its complexity, while ordinary digital implementations remain within the same notion of computability.
In this picture, the prompt is the program. The LLM supplies the general intelligence that executes it; the harness supplies the operations through which execution proceeds. A prompt program can describe an algorithm, distribute work, preserve intermediate conclusions, or invoke another prompt program. It can be a single instruction or a repository of interdependent instructions and supporting code. A particular invocation runs the relevant parts of that program.
Holding the model fixed lets us ask how much progress can come from improving the program that runs on it.
A Program That Improves Itself
The idea of searching for a program and its justification together has a theoretical precedent. Given a formal specification, a meta-program can search for implementations alongside proofs of correctness and bounds on their running time. Hutter’s program-search construction makes a powerful version of this precise for programs with the required proofs, although its enormous overhead makes the general construction impractical. Schmidhuber’s Gödel machine takes the self-referential step: its search includes changes to its own software, including the proof searcher, when it can prove the change useful.
A meta-prompt could search for the most efficient prompt meeting a specification, using the world knowledge and intuition already available in an LLM. It could develop a candidate together with an argument for why it should work: which cases it covers, which assumptions it uses, and which steps it eliminates. This is a fallible, intuitive proof sketch that guides testing and revision. The proposal and its justification can evolve together as the system discovers counterexamples. GEPA demonstrates part of this approach by using language-model reflection on execution traces to propose, test, and combine prompt improvements.
Memory is the clearest way to make such improvements persist. In the coding example, saving the new debugging procedure changes the instructions available to later runs. Reflexion already uses stored verbal reflections to improve subsequent attempts without updating model weights. A useful picture of a human is a body carrying an evolving memory: experience changes what the person will do next. An agent’s persistent instructions offer a particularly explicit place to study that process.
The recursive step comes when memory also contains instructions for improving memory. An agent might learn a better way to diagnose a failed procedure, choose an informative test, or decide where a new rule belongs. If those improvements become part of the instructions used in later revisions, the system is improving its own method of improvement. Recursive self-improvement (RSI) can therefore be studied at the level of prompt programs. Meta Context Engineering provides a concrete example of this direction: it evolves both context artifacts and the skills used to construct them.
Many Agents, One Evolving Memory
LLMs make this picture especially interesting because the evolving memory can be shared by arbitrarily many agent instances, given the resources to run them. Each agent can execute the current program while contributing experiments, criticisms, or proposed revisions. A useful improvement can then become available to every agent that adopts the updated memory.
The shared memory is the persistent object across these executions. Individual agents begin and end; the prompt program carries forward what they have learned. That makes it the more fundamental object for studying this kind of self-improvement. Work such as G-Memory, which organizes and updates memories of multi-agent collaboration, has begun exploring how experience can accumulate at the level of a team.
Taken to the limit, this raises an exciting possibility: with unlimited resources, could memory improve itself arbitrarily fast? That would require useful exploration, evaluation, and integration all to scale together. More agents can test more candidates, but making their contributions compose into a better common program is itself an intellectual task. Successive discoveries may also depend on one another. How far this process can scale is a major open question for Intelligence Science.
Memory Needs an Engineering Discipline
Why has memory not already delivered that kind of RSI? My working hypothesis is that much of the gap comes from missing engineering discipline. I expect substantial progress from learning how to structure and maintain prompt programs. Failures of particular memory architectures do not establish a fundamental weakness in the medium.
Equating prompts with programs immediately opens a much larger design space. A program might fit in a single AGENTS.md. A mature system might eventually need a repository with millions of lines of interdependent prompts, interfaces, tests, and supporting code, just as modern software does. Its organization would determine which instructions are used together and how changes propagate through the system.
A directory of independent skills is one special case, and I doubt it is the best general architecture. Suppose several abilities depend on the same reasoning procedure. Copying it into each skill creates several places that must change when the procedure improves. A shared module gives that procedure one home, while explicit interfaces make its dependencies visible. The right structure should emerge from the relationships among abilities.
This also suggests why memory can degenerate into a dump. A growing list of lessons can contain conflicting instructions without specifying which one applies. Rewriting the entire memory introduces a different failure mode: useful detail can disappear. Agentic Context Engineering documents this loss during repeated rewriting and uses structured, incremental updates to address it. The representation of memory and the procedure for changing it are research variables with consequences for learning.
The counterparts of familiar computer-science fields become concrete:
- Programming languages and software engineering: How should prompt programs express abstractions, share procedures, expose dependencies, and support tests and refactoring?
- Compilers: How should a system transform a prompt program into the instructions, tool calls, and agent structure used for a particular task?
- Operating systems and distributed systems: How should agents share memory, coordinate revisions, integrate compatible changes, and recover from bad ones?
- Algorithms and complexity: Which search and reasoning procedures improve these programs efficiently, and how does their performance change as more agents participate?
These questions give the engineering hypothesis something to work on. Memory needs ways to acquire structure and improve that structure as its abilities grow.
Metaflow as an Operating System for Memory
Metaflow aims to take a first step by providing an operating system for evolving memory: a suite of meta-reasoning instructions that facilitates the adoption of new abilities.
The intended responsibilities are practical. Turn a proposed ability into a coherent prompt program; identify the existing procedures it should reuse; build checks for its behavior and interactions; and integrate it into the shared memory with a way to revise or roll back the change. Domain abilities are the applications. The meta-reasoning instructions organize how those applications become part of the system and continue to evolve.
Those instructions should themselves be open to improvement through the same process. The ambition is a memory whose ability to acquire new abilities can itself improve.