Monthly Archives: October 2026

Jac Lang

I love exploring new programming languages and I came across a brand new one which combines the concept of Agent design with Code. This fascinating language is called ‘Jac’.

The website: https://jaclang.org/

This is at that exciting stage of maturity where the concepts are still being built up and sometimes examples on the slick website do not work ‘out of the box’. All of this is well compensated by the Two Ideas and the Four Concepts behind Jac.

2️⃣ The Two Ideas

Synechic Surface – this is the concept of codespaces where the same program can contain code that runs in different environments – for example the client and the server. The compiler derives the execution environment based on the code imports present in a given codespace. All the code for the app in one place. Agent-coding heaven.

Topokinetic Core – one word – graphs! Yes – graphs are first class constructs and all data is interconnected. This allows connected context to be built out and ‘walked’ over by AI Agents natively (syntax support for graph creation and navigation). The graph construct can be persisted so you can always maintain context.

4️⃣ The Four Concepts

Built on the idea of Synechic and Topokinetic we add two more to give the four concepts.

Model-backed Functions – functions natively implemented by LLMs. No more creating wrappers/boilerplate with templates for prompts. You can describe the function using semantic hints and offload to LLMs (Jac provides native integration to LLM providers).

Walkers – giving the AI Agents the flex to create and manage state as a graph and then walk over it to execute tasks on matching nodes. With a language likePpython you would need to create queries for a backing graph store with a ton of boilerplate and performance implications as data shuttles back and forth.

Are we in nerd heaven yet?

Putting it all together…

Graph + Walkers give you a fully navigable context layer that can be fed to AI via LLM-backed functions.

Add Codespaces – you get combined applications that can be assigned execution targets where the client and server can operate over different graphs and maintain their own context.

LLM-backed functions also remove the boilerplate of integrating with LLM harnesses and make the whole application ‘one with the LLM!’.

The Gotchas…

There will be a lot of magic under the hood where I expect it will be difficult to understand what is going on in an app. Currently model integration via prompts gives a clean separation between deterministic code and prompt-and-reason (then pray).

Graph + walkers are good and I feel that this will bring some relief but also graphs are difficult to reason about and cannot give the same guarantees as a well-defined table in a relational store. So walkers will need to be resilient and loosely coupled to the underlying data structure.

Codespaces are the real nightmare, as they break down the barriers between what was always considered as a ‘sacred contract’ between the client and server to allow scaled consumption.

The Verdict…

It’s still quite early in the day for Jac but it does bring some interesting concepts to life. I am going to explore it and create some examples to showcase the above.

I have created a small Open Knowledge Format style bundle for you to quiz and gain knowledge:

https://github.com/amachwe/jac_okf

Code examples:

https://github.com/amachwe/jac_test

God at the Bottom of the Stack

The first gulp from the glass of natural sciences will make you an atheist, but at the bottom of the glass God is waiting for you.

– Attributed to Werner Heisenberg

There is uncertainty about the attribution of the above quote which fittingly reflects the uncertainty of reality (a quantum pun on the Heisenberg Uncertainty Principle).

The Stack

One of my favourite topics to think about is the Reality Stack and what is at the bottom. From the early days of humankind we have always wondered what makes the world tick and we have been peeling back the layers one step at a time.

The Reality Stack is as follows:

  1. Dependent Theories (Biology and Chemistry) that depend on physics and one day might get a full physical representation.
  2. Classical and enabler theories that describe the reality of everyday experiences (Thermodynamics, Classical Mechanics, Gravity, Statistical Physics etc.)
  3. Advanced theories that start to describe reality at the edge (General Relativity – at cosmic scales, Special Relativity – approaching light speed, and Quantum Mechanics/QFT/Standard Model – defining the building blocks of reality).
  4. Conceptual theories that are attempting to unify cosmic scale effects with the building blocks of reality (AdS/CFT, SO10, SU(5)).
  5. Does another layer exist…?

We know also that this stack is fast approaching limits of human cognition especially as AI is helping with research.

Items (1) and some of (2) are taught during school years and then five years of graduate/post-graduate study is enough to make you aware of (3). But (3) and (4) will take you years to master and the route lies via a Ph.D., and post doc followed by a research career in Mathematics or Theoretical Physics (or liberal use of Claude as per recent news items).

By the time you start (5) you agree with the above quote and think maybe there is a supreme entity, master controller, God, game master etc. running the show.

Similar stacks exist in other areas as well but they all end up at (5) above (at the time of writing this). For example in Computing:

  1. No code: drag and drop software creation where the developer is completely unaware of the application structure and how it executes.
  2. Low code: some portions of the application are crafted by a human therefore limited visibility of application structure and execution flow.
  3. Software Development using business focussed languages (e.g., Java, Python): focus on application structure and logic flow but low level details such as memory management, network communication, process management, and execution optimisation still outside the developer’s knowledge.
  4. Software Development using low-level or assembly languages: full visibility right down to how each data item is being stored, managed, moved etc.
  5. Binary: writing out applications on specific micro-architectures where you are painfully aware of the hardware, that is ultimate nerd heaven at the cost of a good night’s sleep.
  6. Continue from Layer (2) of the Reality stack…

Entering the Fog

The fog that hides a complete description of reality behaves differently for physics (where it pushes down) and logic (where it pushes up). Two famous results (Gödel’s Incompleteness Theorem and Turing’s Halting Problem) keep the fog firmly in place going up the layers, and a missing Theory of Everything keeps the fog in place going down the layers.

Looking at the computing stack the bit on the system is not aware of the electrons that we are using to give it that value just as the silicon substrate is not aware of the protons and neutrons that make it up. Those protons and neutrons are not aware of the quarks that make them. We have entered the fog of reality. In fact, are quarks at the bottom? If yes then what is that ‘bottom’ resting on? Is it even a real thing or just a ‘field’? Are ‘fields’ real?

Just like a computer program cannot reason about the system driving nor prove consistency as there will always be statements that cannot be proven within that system. We can escape to a layer above but then end up with a different set of unprovable statements (locked in by Gödel’s Theorem).

The Fog in the Brain and AI

Similarly the human brain is made up of different network types responsible for specific functions such as processing sensory data, problem solving, and reasoning. One of the big mysteries is what makes these networks work together to provide us with what we experience as ‘consciousness’. The stack here extends from us observing some text on the screen down to chemical and electric signals in our brain back to layer (2) of the Reality stack. The fog then takes over.

Often we cannot articulate (pierce the fog) the reason behind a decision. We use words like ‘instinct’, ‘gut feeling’, ‘intuition’ etc. to acknowledge the fact that the brain cannot directly observe its own workings. Philosophy takes the approach of a mini virtual human inside our brains driving the real us. But then we come to the same question about the ‘bottom’: who is driving the mini virtual human inside our brain?

Looking at AI models we find similar stacks and as we go from small sections of the network to the whole model scale we start to lose situational awareness. The training process for AI brings all the networks together and bakes in the coordination (e.g., MoE approach). But even if we ask an AI model for an explanation for a given output it often just generates a plausible response rather than the actual method followed as it suffers from the same fog. It cannot completely analyse its own reasoning. This has been highlighted in various papers from OpenAI and Anthropic.

  • Anthropic’s “On the Biology of a Large Language Model” (2025): Claude described doing addition by carrying the one, while internally it used parallel approximate and exact paths.
  • Anthropic’s “Reasoning Models Don’t Always Say What They Think” (2025).
  • Turpin et al. (2023), “Language Models Don’t Always Say What They Think”.
  • OpenAI’s 2025 work on chain-of-thought monitoring.

Conclusion

We are now very far in from our first gulps. We are not yet sure if we are drinking from a glass or a hosepipe. Nor do we know if someone else controls the glass/hose-pipe and how much influence we can exert.

Cheers to the next gulp!