François Chollet: ARC-AGI-3, Beyond Deep Learning & A New Approach To ML
In a Nutshell
François Chollet launches ARC-AGI V3, a benchmark testing agentic intelligence via interactive mini-games that demand efficient exploration, goal-setting, and planning in novel environments, resisting brute-force scaling seen in V1/V2 saturation by coding agents. Through NDIA, he pursues symbolic descent—replacing gradient descent with program synthesis for concise, optimal symbolic models that need far less data, generalize better, and emulate human-like skill acquisition efficiency toward AGI by 2030. Deep learning excels in verifiable domains like code but falls short on true fluid intelligence; future AGI will be a compact, self-improving codebase leapfrogging current stacks, with advice to explore discarded 1970s/80s AI ideas and build scalable open-source projects with intuitive APIs.
These notes were generated by AI and may contain inaccuracies.
AGI around 2030, coinciding with ARC 6 or 7 release. AI progress cannot be stopped and will accelerate. Question is how to make use of it and ride the wave.
François Chollet, founder of ARC Prize, global competition to solve ARC-AGI benchmark. Latest project: NDIA, lab exploring new paradigm in frontier AI research. Congrats on ARC-AGI V3 launch.
Thanks so much for having me. I'm super excited to be here. Super exciting time to talk about AI.
NDIA is new AGI research lab trying different ideas to build new branch of machine learning much closer to optimal, unlike deep learning.
Current focus on coding agents; speaker's GStack open source project reached 40,000 stars with over 100 PRs from contributors.
NDIA does program synthesis research at much lower level than codegen or coding agents. Building alternative to deep learning itself, rebuilding the whole stack on different foundations: new learning substrate different from parametric deep learning.
Machine learning: input data to target data, find function mapping inputs to targets that generalizes.
Deep learning: parametric curve fit via gradient descent.
NDIA replaces parametric curve with symbolic model as small as possible (simplest model explaining data). Cannot use gradient descent; instead, symbolic descent (symbolic equivalent of gradient descent).
New machine learning engine produces extremely concise symbolic models. Will scale to replace everything done with parametric models.
Closer to optimality: needs much less data, models run efficiently at inference (small size), generalize and compose better.
Minimum description length principle: model of data most likely to generalize is the shortest. Cannot find such model with parametric learning; need symbolic.
Industry pours billions into LLM stack, which works and has returns, but counterproductive for everyone to work on same thing.
AI in 50 years not built on this stack; inefficient, may get to AGI but not optimally. AI will trend towards optimality; NDIA leapfrogs to optimal foundations today.
Vision ambitious, 10-15% chance of success, but worth trying: big impact if works, no one else doing it.
If you have big idea with low chance of success but huge if works, and no one else working on it, you should try.
Success of coding agents surprised many, including speaker.
Reason: code provides verifiable reward signal. Any problem with formally verifiable solutions (trustworthy reward, not model guess) can be fully automated with current LM stack. Code first domain to fall; mathematics next (verifiable theorems/proofs).
Challenge: make domains verifiable (code natural: tests, compiles; math: proofs work). Harder for fuzzy domains like English essays.
Reasoning models progress slow in non-verifiable domains (e.g., essay writing) because LM stack operationalizes training data from costly human annotations.
Verifiable domains unlocked by code-based training environments with unit tests etc. for post-training: model tries things, verifies, generates more signal data, denser problem space coverage, builds execution trace models (track variables like human programmers).
Impossible for essays, law, etc.
AGI definitions: industry says system automating most economically valuable tasks (automation, not intelligence).
Chollet's definition:
AGI: system approaching any new problem/task/domain, making sense of it, modeling it, becoming competent with same efficiency as human (same data/compute; humans very data-efficient). Human-level skill acquisition efficiency on human scope of tasks.
Possible to automate economically useful work before true AGI (current trajectory; current tech automates verifiable reward domains at human level or beyond, code first).
True AGI (human learning efficiency on arbitrary tasks) needs different technology/mindset.
LLMs possibly bent to AGI-like with enough compute (great equalizer), but not LLMs per se; new layers above (LLMs as compute). Wrong/inefficient; future AI lower level, trending to optimality.
Chollet long-time deep learning practitioner; initially believed deep learning could do everything (Keras creator, deployed NLP models 2014; released Keras March 2015).
2015-2016 view: deep learning extremely general, training-complete, differentiable programming (train on inputs/outputs for any software task).
2016 Google Brain research: training deep models for reasoning/first-order logic/theorem proving. Gradient descent couldn't encode crisp reasoning algorithms (not representation issue; optimization failure). Led to overfitting/pattern matching over sequences.
Idea: need program synthesis benchmark like ImageNet for reasoning. Brainstormed 2017: tried solar automaton (recreate program from outputs). Settled on ARC-AGI format early 2018 (side project while developing Keras).
Summer 2018: wrote ARC task editor, hand-made 10,000 tasks. 2019 paper: intelligence as skill acquisition efficiency.
ARC obscure until ChatGPT (late 2022); performed badly. Niche program synthesis community knew it; deep learning/LLM scalers ignored (too hard, LLMs failed).
Benchmark needs some success to attract attention.
ARC versions:
- V1: base LLMs sub-10% (GPT-3 zero; latest base models as of March still low), even after 50,000x scaling.
- Reasoning models (o1, o3) cracked V1: step function change; signaled new capabilities (OpenAI demoed on ARC as unsaturated reasoning benchmark).
- ARC-2: same format, harder (more composition in reasoning chains). Early reasoning models low; saturated recently with coding agents paradigm.
ARC provides verifiable rewards.
Frontier labs targeted ARC-2 at large scale: reasoning model generates more tasks, solves via program induction, verifies (trustworthy), fine-tunes on successful chains. Repeat millions of times (RL loop; brute-force space).
New AI paradigm: verifiable domains enable this loop for high performance.
Not higher fluid intelligence; new post-training paradigm (same as agentic coding).
Models more useful without being smarter: trade-off between intelligence and knowledge. Coding agents: better trained via trial/error with true rewards + embed code execution model (track variables over execution).
Changing software engineering.
Poetic founders: agent harness structures domain for formal verification.
Confluence Labs (Winter '26 batch): saturated ARC-2 at 97% with efficient task cost, built harnesses for LMs to generate tasks/program. Worked couple months to saturate long-standing benchmark.
Progress in AI is driven by custom harnesses around tasks, which allow human programmers to input higher-level solution strategies into models. The need for humans to engineer these harnesses indicates a lack of AGI today, as AGI would create its own harnesses and figure out problems independently. Harnesses are effective for task automation at scale but do not advance toward AGI.
ARC V1 and V2 focused on producing causal models of given static, passive data, emphasizing modeling. V3 measures agentic intelligence, which is interactive and active: agents are dropped into new environments like mini video games without instructions, goals, or controls, figuring everything out via trial and error.
Key Abilities Tested in V3
- Exploration efficiency
- Acquiring goals independently (goal setting)
- Planning through an environment model and executing plans
V3 seeks AI that learns to play and crack these games with human-level action efficiency (hundreds to thousands of actions). All V3 environments are solvable by humans with no prior training, as tested on regular people. Humans excel at efficient exploration and cracking new games from scratch upon first contact.
Frontier models struggle with V3. While reasoning models cracked V1 and reinforcement learning cracked V2, V3 requires new advances. It resists data-contamination strategies seen in V2 by having a private set of significantly different environments. The public set is easier and not representative of private set performance, making it harder to target and a better test of fluid intelligence rather than effort in cracking.
Over 250 games were created via a dedicated video game studio with a productive pipeline: design, implementation, review, human testing, and multiple iteration cycles (multiple games in progress weekly). Each game takes ~10 minutes or less to solve from scratch.
Game Studio Details
- Hired team of game developers from the video game industry
- Built custom game engine
Games are unique, avoiding borrowed elements from existing video games. Built on core knowledge priors: basic physics, objects, agents with goals and intentions. No language, cultural symbols (e.g., arrows, green for go, red for stop), or external knowledge.
V3 is interactive, requiring agents to gather data efficiently by creating their own path through game space. Brute-forcing all states scores low due to efficiency penalties; must match human-level efficiency.
Early efforts like OpenAI's work on Dota 2 (OpenAI Five, pre-GPT, stack of LSTM layers) and DeepMind's Atari games (2013) trained on the same environments as testing, memorizing strategies via millions of frames or tens of thousands of hours. V3 evaluates on entirely new games, with every exploration action counting toward efficiency score, focusing on fluid intelligence: efficient exploration, world model creation, goal inference, planning, and cracking.
ARC tasks cost ~$0.3, while foundation models cost $1–$10 for the same. Intelligence in LLMs distills into smaller models, suggesting AGI is not inherently about billions of parameters or scaling.
Platonic ideal of AGI: Fluid intelligence engine as a very small codebase and models (~megabytes), drawing on a large knowledge base underneath.
"I do believe that when we create AGI retrospectively it will turn out that it's a code base that's less than 10,000 lines of code and that if you had known about it back in the 1980s you could have done AGI back then using the compute resources available back then."
Cyc failed partly due to no learning: purely symbolic, hand-crafted, inaccurate knowledge. AGI requires removing humans from the improvement loop for compounding self-improvement. Deep learning excels here by scaling knowledge via data and compute with minimal human involvement.
Ideal system: self-improving with compounding capabilities, where capability gains accelerate further gains.
Science is symbolic compression: compressing observations (e.g., planet positions) into simple symbolic rules/equations, not curve-fitting. NDIA's program synthesis recreates the scientific method algorithmically: replace parametric curves with shortest symbolic models.
Elegant solutions to hard problems are short; messy overengineered ones are longer (Pascal's essay analogy).
LLMs do not learn like humans (no baby reads the internet). Humans perform program synthesis messily, implementing fundamental intelligence principles. Reimplement from first principles for efficiency, not biological plausibility. Human mind builds symbolic causal models (objects, agents, relations) for generalization and novelty adaptation.
Started day one with symbolic program synthesis vision: deep learning-guided program search in combinatorial spaces (like AlphaGo/AlphaZero) to break combinatorial wall.
Tried many ideas; took ~half a year to reach compounding foundations. Key: build reusable, compounding stack—don't constantly restart without reusing learnings. Commit to right foundation without rushing.
ARC series targets residual capability gaps as frontiers advance; moving target, not fixed AGI test.
- ARC 4: Focus on continual/curriculum learning at long timescales; fewer games with compounding levels requiring reuse of prior learning.
- ARC 5: About invention (details forthcoming).
Will continue to ARC 6/7 until no measurable human-AI gap, marking AGI. Then machines create ARC-ASI.
AGI timeline: Early 2030s, extrapolating progress and investment across stacks (LLMs, NDIA, etc.).
Compute equalizes approaches; scaling investment into alternatives (e.g., genetic algorithms) would yield exciting results, potentially automating science via search.
Promising alternatives:
- State space models (e.g., Mamba/XLSM architecture)
- Recurrent models over transformers
- Search/evolution over gradient descent
- Lowest level: Discard parametric curves/gradient descent entirely (NDIA's level)
Optimal AI requires foundational changes, not just layers on existing stacks.
Read 1970s/1980s AI papers: broader exploration before collapse into single approaches (e.g., SVMs ~20 years ago; neural nets dismissed as failed until recently). Avoid crowded paths; discarded ideas (e.g., genetic algorithms) hold tremendous potential despite low current investment.
Few people are deeply investigating scaling up alternative approaches beyond deep learning. Scalable approaches are essential; if increasing system capabilities requires ongoing human engineers and researchers, it will not work. Even clever, elegant ideas will have bounded capabilities limited by human investment. Systems must improve capabilities with no human in the loop, baking in recursive self-improvement from the start—not just replicating past methods from 10 years ago.
Deep learning exemplifies scaling without human bottlenecks: models improve by adding training compute and data, decoupling improvement from direct human effort. While adding these requires human involvement, the core idea holds. Large language models leverage pre-existing human effort like the internet's creation. Now, training in interactive verifiable environments requires minimal human effort to create the environment, generating exponentially more training data. Initially, priming requires tremendous human-generated abstractions encoded in text data to enter this loop.
For starting an open source project like GStack, with 10,000 to 30,000 daily users:
- Focus on a simple and intuitive API, inspired by scikit-learn, the original easy-to-start machine learning library for Python.
- Prioritize full usability: smooth onboarding, informative docs that teach the domain and the tool's purpose, as users are often newcomers to deep learning.
- Invest heavily in community building.
- Hire power users and fans from the community—they are the best contributors.
Keras succeeded through these factors. It started solo but grew with a team at Google maintaining it excellently. Projects can mature beyond the founder, becoming independent.
The more expertise you have, the better you leverage AI tools. AI progress is empowerment.
Avoid pessimism about job loss or AI takeover. Expertise in areas like programming enables using AI beneficially. Learn deeply about AI and your target domain to turn AI into a personal tool for improving life. AI progress cannot be stopped; it's accelerating. The key question: how to leverage it and ride the wave?
Thanks for the discussion.
Keep Y Combinator in your library
Save the videos and channels worth coming back to, and find them again in one place.
