Program synthesis: Ndea's path toward AGI

Program synthesis is the automatic discovery of a program that satisfies a request expressed through constraints, examples, or a specification. Ndea aims to combine this search for programs with deep learning to build systems that can adapt to new problems. It presents the approach as a research hypothesis for reaching AGI.

Finding an executable rule from a desired result

In conventional programming, you write the operations a machine should perform. In program synthesis, you describe the behavior you want, and a system searches for the operations that produce it. The request might consist of input-output pairs, a demonstration, or logical properties that the result must satisfy.

Microsoft Research’s overview of the field uses this broad definition: discovering executable code from user intent expressed in different forms. Program synthesis therefore extends beyond generating code from a sentence, and its applications are not limited to research on general intelligence.

Imagine a task involving file names. You provide examples in which a person’s first and last names become initials followed by the last name. The system must identify which fragments to keep, which separators to remove, and how to put the pieces back together. The desired result is a procedure that also works on the next file.

That procedure represents a hypothesis about your intent. If none of the examples contain a compound last name, several rules may fit the examples yet produce different results later. Finding a program that matches the examples does not establish that it meets the underlying need.

The ability to apply a rule beyond the observations connects this topic to generalization. Our reference page on program synthesis covers the methods and their history; the focus here is their role in Ndea’s approach.

How a search for programs works

To make the problem manageable, a system needs a defined search space. In the file-name example, the available operations might include splitting a string, selecting a fragment, taking an initial, and joining the results. The system explores combinations of these building blocks.

A simple loop illustrates the process:

1. Describe the inputs and expected outputs.
2. Define the allowed operations and the rules for combining them.
3. Propose a candidate program.
4. Run it on the available examples.
5. Reject incompatible candidates and choose among those that remain.

Suppose the intended transformation preserves the entire last name. A rule that takes only the final fragment might work on the initial examples, then fail on a compound last name. A counterexample can eliminate that rule or help clarify the request.

The choice of language matters as much as the search itself. A very limited vocabulary makes exploration easier but may leave the system unable to express the solution. A richer language supports more behaviors while creating more possible paths through the search. The system must also handle programs that fail, loop indefinitely, or consume too many resources.

The search can favor shorter solutions or programs that reuse familiar operations. This is a search preference, not a guarantee of correctness: the shortest rule might ignore an essential exception. In practical use, the quality of the specification and testing on new cases remain decisive.

Why Ndea wants learning to guide the search

The practical difficulty soon becomes apparent: as operations are combined, the number of possible programs grows with the depth of those combinations. An unguided search can spend substantial computing resources exploring candidates unrelated to the task.

In its official overview, accessed in October 2026, Ndea advocates program synthesis guided by deep learning. According to the lab, a network can direct exploration toward promising programs, while executing those programs allows the system to check its hypotheses against observations. Ndea presents this combination as the core of its approach to general intelligence.

To understand the division of work, imagine a colored-grid problem. A pattern recognition system suggests that the transformation involves symmetry. The search then prioritizes reflection operations and combinations of them, rather than examining every conceivable transformation. The proposed programs still have to reproduce the examples.

Ndea’s ambition is to bring pattern recognition and formal reasoning together in a shared architecture. That ambition alone does not amount to a complete method with established performance across the board. The lab’s claims about the limits of deep learning and the potential of this combination should be read as its research position.

The appeal of this approach rests on a specific question: can a system use previously acquired knowledge to discover a new rule efficiently? Meeting that standard requires more than producing a plausible program.

What published research already shows

Combining neural networks with symbolic search is not unique to Ndea. Published research makes it possible to examine how these methods work without assuming that they will lead to general intelligence.

DreamCoder, described in a research paper, jointly learns a library of components and a network that guides program search. It builds reusable abstractions from the solutions it discovers. It also trains its search guidance on replayed or generated problems.

The idea is concrete: if the same sequence appears in several solutions, it can become a new building block. Later searches can use that block directly. Learning therefore changes both the solutions the system can find and the vocabulary available for expressing them.

This work provides an example of a system that connects search, learning, and reuse. It does not establish that this organization is sufficient for learning in any environment. The tasks studied, the available representations, and the resources allocated are all part of the result.

The ARC Prize 2024 technical report also describes program search among the approaches explored on ARC. It distinguishes inferring a procedure from directly predicting an output, and reports the value of combining those approaches in that edition.

These historical results document methods; they do not describe the state of the rankings in October 2026. When assessing a recent result, our article on benchmarks and the conditions needed for comparison helps you examine the evaluation protocol rather than the score alone.

The connection to François Chollet’s account of intelligence

In On the Measure of Intelligence, published in November 2019, François Chollet proposes characterizing intelligence in terms of skill acquisition efficiency. His analysis calls for taking prior knowledge and experience into account: strong performance may reflect extensive preparation rather than a strong ability to adapt.

Program synthesis is relevant to this perspective because it provides a way to infer a rule from limited observations. But it does not remove prior knowledge from the equation. The search language, available components, and guidance model already encode design choices and learning.

Consider an exercise that requires moving an object to a boundary. If the system already has an operation dedicated to that movement, discovering the solution is easier. If it must construct that operation from elementary manipulations, the difficulty changes. An evaluation needs to account for that difference.

The article On the Measure of Intelligence explained explores this distinction between skill and learning efficiency. It helps avoid automatically treating a visible success as evidence of more general intelligence.

Program synthesis is therefore not proof of AGI. It offers a framework for studying how a system discovers and reuses procedures. Establishing general applicability then requires measuring transfer, resource requirements, and dependence on representations prepared in advance.

What ARC can measure and what remains unproven

In ARC’s grid tasks, examples demonstrate a transformation, and the system must produce an output for a new input. A synthesis approach searches for a procedure consistent with the demonstrations, then applies it to the requested case.

The technical notes published by ARC Prize in October 2024 describe this approach combining deep learning and program search. They outline a technical direction; they do not demonstrate that all intelligence can be reduced to this arrangement.

In a hypothetical example, the demonstrations might suggest keeping the largest object. A procedure could pass those examples yet fail when two objects have the same size. It might also accidentally rely on a color shared by the demonstrations. The program can be executed and inspected, but whether it captures the intended rule still needs to be checked.

Moving from these exercises to open-ended problems introduces further difficulties:

• observations may be incomplete or noisy;
• the correct result may be difficult to verify automatically;
• goals may remain ambiguous;
• an action may change the environment before the hypothesis has been validated.

These obstacles explain why success on a benchmark needs to be understood within that benchmark’s scope. For more on the different types of tests and their limitations, the reference page on AGI benchmarks provides additional context. A program that explains the examples proves neither that its rule is unique nor that the rule will hold elsewhere.

How to assess reported progress

When following this research in our AGI coverage, the useful criterion is a demonstrated ability to solve new tasks under documented conditions. An architecture announcement describes a proposed means to an end; an evaluation must show what it actually achieves.

Relevant questions include which components were available before the test, how much computation the search used, and how many candidate programs were executed. Failures matter too: a system may succeed on some task families yet remain unable to express a solution in a different representation.

Convincing progress should also distinguish the contribution of each mechanism. Does guidance reduce the amount of search required? Do learned abstractions help on new tasks? Does the result hold with a comparable resource budget? These questions help assess the combination without attributing every improvement to a single idea.

Key takeaways

• Program synthesis searches for an executable procedure from a description of the desired behavior.
• Ndea proposes guiding that search with deep learning; its potential as a path to AGI remains a hypothesis to evaluate.
• Published research shows how systems can learn search guidance and reusable components within defined settings.
• Passing the examples does not guarantee generalization: the evaluation protocol, resources, and performance on new cases determine what a result establishes.

Frequently asked questions

Does program synthesis require a language model?

No. A system can explore a restricted language using search methods or logical solvers. A neural network can help it select promising candidates, but this guidance is not part of the definition.

How does program synthesis differ from compilation?

A compiler translates an existing program into another language while preserving its behavior. Synthesis has to discover the program from a description of what the user wants, which often leaves several possible solutions.

Can a synthesized program be proved correct?

In some formal settings, a proof can establish that a program meets a given specification. That guarantee still depends on the assumptions and specification used. Passing a set of examples does not, by itself, provide such a proof.

Does Ndea's approach mean AGI is close?

A research direction does not provide a reliable timeline. Assessing progress requires reproducible evaluations, information about the resources used, and evidence of transfer to new problems. A lab's stated ambition cannot substitute for that evidence.