Cognitive Flow Oriented · v0.4.0
Stop chaining prompts. Start engineering systems. Axon gives you a runtime, a memory model, and a flow language — so what you build today scales into something real tomorrow.
Paradigm shift
Each era solved the problem of its time. Axon solves the one of this era.
Runtime
Axon doesn't run on top of another language. It has its own runtime compiled in C++17 — with a thread scheduler, an execution graph with cycle detection, and a finite state machine per actor.
Each actor moves through well-defined states. If it fails, the runtime decides what happens next according to the declared contract — not according to imperative code the developer forgot to write.
What an operating system does for processes, Axon does for actors: lifecycle, memory, communication and concurrency — managed by the runtime, not written by hand.
Build once. Run anywhere. Scale to millions.
Powered by the Axon Runtime
Philosophy
Most frameworks evolve by changing their foundations. Axon will evolve by expanding them.
.png){kind=logo}
main {} is code you write. Both live in the same file. Neither gets in the way of the other.Universal Computational Graph
Every node has a type and a contract.
A flow starts execution, triggers agents, which run tasks, which can invoke other agents or entire flows —
forming an execution network that the runtime traces, validates and optimizes.
Memory System
Each actor declares what it remembers and for how long. No hidden state — the memory model is explicit, managed by the runtime, and observable in every execution.
Parallel Runtime
parallel {} is not a promise.When you write parallel {} in Axon, the C++17 scheduler assigns each actor to a real worker in the thread pool — not to an event queue, not to cooperative coroutines taking turns.
No GIL. No interpreter yielding control between instructions. Every core does its work in true parallel, and the runtime synchronizes the results when all of them finish. The same code takes advantage of 4 cores on your laptop and 64 on a production server — without changing a single line.
Inside a parallel {} block you can mix completely different agents — with different models, different tasks, and different memory — and the runtime coordinates them as if they were one.
Compute
Axon doesn't assume your infrastructure. Each agent declares exactly how it wants to run — which hardware, how many layers on GPU, how many CPU threads. The runtime enforces it. No guesswork, no silent fallbacks you didn't ask for.
compute = auto tries GPU first and falls back to CPU silently. compute = gpu forces it. compute = cpu never touches the GPU. You decide — the runtime respects it.num_gpu = -1 and your lightweight validator on CPU with num_thread = 4 — simultaneously.gpu_fallback = true and the runtime automatically retries on CPU if the GPU returns a hard error. Your flow keeps running. Nothing breaks silently.num_gpu, enable f16_kv to halve KV cache memory usage, or activate low_vram mode for constrained environments.Transport Layer
Axon is not tied to a single machine. Your flows can connect local instances, networked servers, and cloud services using the same actor model — without changing the flow logic.
Consensus in design · open RFC
Consensus is a module where multiple actors debate a decision. Each one with its own context and accumulated accuracy history — the runtime knows who has been right before and gives them more weight in the collective decision.
The result is not just a "yes" or a "no". It's a traceable decision: which actors voted for what, why the ones with higher accuracy tipped the balance, and what arguments the dissenters presented.
Collective intelligence with full traceability. Not a black box — a panel with minutes.
Use cases: evaluate whether to ship a feature · audit code from multiple perspectives · validate strategy with specialized actors · hiring decisions · risk analysis
Working in Progress
A direct look at the implementation state of the language — no marketing roadmap, the real state of the code today.