Principled Machines
Contact us

N-02ApproachPrincipled MachinesOctober 20265 min readDraft

Recipes, abstractions and taste

AbstractComputer science already has most of the recipes reliable agents need. We look at program synthesis, small languages stacked and compiled down, process calculi and planning that adapts, and argue the skill is in picking among them.

We spent decades building software that was precise: algorithms with known bounds, recipes proven and reused a million times over. Everything we reliably know was earned the same way. Look at the world, work out what causes what, state a theory precise enough to be wrong, test it, and keep what survives.

We think the recipes and the algorithms already exist. What is missing is taste in deciding what to optimize. Cortex is built on that belief, with language models where meaning is the question and the rest of computer science for everything else.

Programs, written for the problem

François Chollet defines the intelligence of a system as "a measure of its skill-acquisition efficiency," and asks that we "stop thinking of “agents” as monolithic black boxes."[1] He reads his own benchmark, ARC, as "a program synthesis benchmark." A program can be read, run again, and handed to someone else. A language model proposes programs well; running them is the computer's job. So the unit of work we want is a small program written for the task, in a bounded language shaped to the domain. Jon Bentley called these little languages.[2] Restricting what a language can say makes its programs easier to analyse.[3] Systems such as DreamCoder go further and grow a library of abstractions from solved problems, so that later problems are solved faster.[4] Nobody should have to rediscover what the last problem already settled.

Workflows that change while they run

Which steps are needed depends on what earlier steps find, and new conversations, tools and obligations appear at run time. A flowchart draws the paths in advance, and the global states of interacting parts multiply combinatorially as parts are added.[5] Process calculi describe the same behaviour by composing small processes with algebraic laws. Hoare's CSP gives communicating sequential processes;[6] Milner's π-calculus adds mobility, so the structure of communication can change as the process runs.[7] A study of fifteen commercial workflow products found none that supported all twenty workflow patterns;[8] Puhlmann and Weske encoded all of them in it.[9] Van der Aalst disagrees, calling the π-calculus "a language for experts where simple things suddenly become very complicated."[10] Our bet is that dynamic agent work is better stated as composed processes than as drawn graphs.

Plan, then execute, then replan

Some planning belongs up front. Writing the whole plan first saves tokens and lets independent steps run in parallel.[11][12] Recursive Language Models plan in code: the model writes a program that breaks the input into parts and calls itself on each, runs it, reads the result and plans again.[13] Other planning cannot know upfront and has to wait for what the world says. Decomposing a step further only when it fails beat a fixed plan by 25 points on a crafting task.[14]

Layers, compiled down

Halide separates an image-processing algorithm from its schedule, the choices of how it runs on a machine. The same algorithm can then be tuned for each machine without being rewritten,[15] and the schedule itself can be searched for automatically.[16] MLIR generalizes the idea to whole compilers: a program is lowered through a stack of dialects, each a small language translated into the one below.[17] We want agents built the same way. Bounded languages layered one on another and compiled down step by step, with the language model writing the top layer, the one about meaning. The spec of what has to be established stays fixed. Which model, solver, search or retrieval computes it is optimized underneath. Dijkstra built an operating system in layers so that each could be tested on its own terms.[18] Abstractions are not dead at all; they are the oldest recipe for reliability we have.

Accuracy comes from specialization, and we think the move to it is inevitable. A fully general intelligence is not something you can depend on to be accurate. On ARC-AGI-3 the same model scored 62.7% with one harness and 99.9% with another,[19] and OpenAI ships a router that chooses between a fast model and a reasoning model.[20] Our own result is in Cortex on τ³-bench. The diagnosis is in Hallucinating intelligence.

How to prove us wrong

  1. Programs do not pay. If, on the same model and budget, answers computed by synthesized programs in a bounded language are no more consistent across runs than answers the model writes directly, the approach is wrong for those tasks.
  2. The schedule does not matter. If changing how a task is computed, with what must be established held fixed, leaves accuracy unchanged, there is nothing here to optimize.

References

  1. François Chollet, "On the Measure of Intelligence," arXiv:1911.01547, 2019, §II.2.1, §II.2.3 and §III.1.4. ↩

  2. Jon Bentley, "Programming Pearls: Little Languages," Communications of the ACM 29(8), 1986. ↩

  3. Marjan Mernik, Jan Heering and Anthony M. Sloane, "When and How to Develop Domain-Specific Languages," ACM Computing Surveys 37(4), 2005. ↩

  4. Kevin Ellis et al., "DreamCoder: Bootstrapping Inductive Program Synthesis with Wake-Sleep Library Learning," PLDI 2021. ↩

  5. Edmund M. Clarke, Orna Grumberg and Doron A. Peled, Model Checking, MIT Press, 1999. ↩

  6. C. A. R. Hoare, "Communicating Sequential Processes," Communications of the ACM 21(8), 1978. ↩

  7. Robin Milner, Joachim Parrow and David Walker, "A Calculus of Mobile Processes, I and II," Information and Computation 100(1), 1992; Robin Milner, Communicating and Mobile Systems: the π-Calculus, Cambridge University Press, 1999. ↩

  8. Wil M. P. van der Aalst, Arthur H. M. ter Hofstede, Bartek Kiepuszewski and Alistair P. Barros, "Workflow Patterns," Distributed and Parallel Databases 14(1), 2003. ↩

  9. Frank Puhlmann and Mathias Weske, "Using the π-Calculus for Formalizing Workflow Patterns," BPM 2005, LNCS 3649. ↩

  10. Wil M. P. van der Aalst, "Pi calculus versus Petri nets: Let us eat 'humble pie' rather than further inflate the 'Pi hype'," 2005, §3. ↩

  11. Binfeng Xu et al., "ReWOO: Decoupling Reasoning from Observations for Efficient Augmented Language Models," arXiv:2305.18323, 2023. ↩

  12. Sehoon Kim et al., "An LLM Compiler for Parallel Function Calling," ICML 2024, arXiv:2312.04511. ↩

  13. Alex L. Zhang, Tim Kraska and Omar Khattab, "Recursive Language Models," arXiv:2512.24601, 2025. ↩

  14. Archiki Prasad et al., "ADaPT: As-Needed Decomposition and Planning with Language Models," Findings of NAACL 2024, §3 and §5, arXiv:2311.05772. ↩

  15. Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand and Saman Amarasinghe, "Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines," PLDI 2013. ↩

  16. Andrew Adams et al., "Learning to Optimize Halide with Tree Search and Random Programs," ACM Transactions on Graphics 38(4), 2019. ↩

  17. Chris Lattner, Mehdi Amini, Uday Bondhugula, Albert Cohen, Andy Davis, Jacques Pienaar, River Riddle, Tatiana Shpeisman, Nicolas Vasilache and Oleksandr Zinenko, "MLIR: Scaling Compiler Infrastructure for Domain Specific Computation," CGO 2021. ↩

  18. Edsger W. Dijkstra, "The Structure of the 'THE'-Multiprogramming System," Communications of the ACM 11(5), 1968. ↩

  19. ARC Prize Foundation, ARC-AGI-3 leaderboard and "GPT-6 Astra" results post, September 2026, arcprize.org/blog/astra. Both runs used ARC Prize's own harnesses, Standard and Provider Adapter. ↩

  20. OpenAI, "GPT-5 System Card," August 2025. ↩

Next noteCortex on τ³-bench