Roadmap

Built in public.
Every phase documented.

No marketing dates, no vaporware. This is the real state of the build — what's shipped, what's next, and what's vision. Updated as the code moves.

View changelog → Contribute to an RFC
Overall progress 6 of 10 phases complete
Phase 1 Phase 6 ← now v1.0.0
Phase 1 complete
Core Runtime
Lexer · Parser · AST · Interpreter

The foundation of the language. Lexer, recursive descent parser, AST tree-walking interpreter, and all the primitives that every phase above builds on.

Language primitives
Native types: string number bool null list dict
Arithmetic, logical and comparison operators · ** power · % modulo
Control flow: if/else if/else · for · while · match
Error handling: try/catch/raise
F-strings with arbitrary embedded expressions
print() · typeof() · line and block comments
CLI: axon run · axon check · axon version
Phase 2 complete
Agents + Flows
LLM orchestration · Actor model · Runtime FSM

The core of the Cognitive Flow Oriented paradigm. Agents, tasks, flows, the pipeline operator, and the full actor lifecycle managed by the C++17 runtime.

Actor model
flow {} · agent {} · task {} · main {}
3 execution forms: Agent(input) · Agent->Task(input) · >> pipeline
task_graph {} with on_success and on_fail per edge
validation {} — confidence threshold, max retries, on_fail behavior
parallel {} — real multi-core execution via C++17 thread pool
Actor FSM: IDLE → RUNNING → SUCCESS / FAILED / FLAGGED
Compute & runtime
compute = auto/gpu/cpu · gpu_fallback = true
num_gpu · num_thread · f16_kv · low_vram
Ollama adapter via REST — no external dependencies
delay · timeout · sleep() per task, agent and flow
Phase 3A complete
Memory — Key-Value
Persistent and volatile memory · 4 scopes · TTL

The explicit memory model. Every actor declares what it remembers and for how long. Four scopes, TTL support, disk persistence, and native methods for strings, numbers and lists.

Memory API
Scopes: runtime · session · shared · persistent
memory->store() · get() · has() · remove() · clear()
TTL support: memory->store(k, v, "runtime", 30)
memory->persist(path) · memory->load(path)
Native string, number and list methods
Dict and list assignment with auto-creation of nested dicts
Phase 3B complete
Memory — Semantic
HNSW index · Native embeddings · Portable .idx

Search by meaning, not by exact text. A native HNSW index with Ollama embeddings that persists as a single portable file — no external vector database needed.

Semantic memory
embedding {} — configure model, provider and dimensions
memory->index(text, metadata) — index content as a vector
memory->search(query, top_k) — search by meaning, cosine similarity
memory->sem_persist(path) · sem_load(path) · sem_size()
Phase 4A complete
File I/O + Document Parsing
Auto-detection · CSV · JSON · date-> · Regex

Native file operations with automatic type detection by extension. CSV and JSON parsers, date utilities, and regex support built directly into string methods.

File operations
file->read() auto-detects format by extension
file->write() · append() · delete() · mkdir() · ls() · exists()
CSV: csv->parse() · stringify() · write() · custom delimiter
JSON: json->parse() · stringify() · write() · configurable indent
Regex string methods: find() · find_all() · replace() · split() · test()
date->now() · format() · add() · diff() · before() · after()
Phase 4B complete
Office + Images + Codec
DOCX · XLSX · image-> · codec-> · hash->

Native reading of Word and Excel documents, image manipulation, encoding utilities and cryptographic hashing — all without external runtime dependencies.

Document + media modules
file->read(".docx") — plain text from Word documents
file->read(".xlsx") — List of Dicts from Excel with auto type detection
image->save() · resize() · info() · convert()
codec->b64_encode/decode() · hex_encode/decode() · url_encode/decode()
hash->sha256() · hash->md5()
Docker Linux mirror build · optional tool detection in CMake
Phase 4C complete
PDF Parsing
Text extraction · Image extraction · MuPDF

Two completely separate extraction paths for PDFs — text and images. Each optimized for its purpose, without one breaking the other.

PDF module
file->read(".pdf") — plain text, simple mode
pdf->parse(path, "t") — structured object with text and pages
pdf->parse(path, "i") — image extraction as base64
FlateDecode + DCTDecode support · PNG encoding via stb_image
Phase 5 complete
OCR + String Index + Tools
Tesseract · string[i] · Tool auto-detection

Text extraction from images via Tesseract OCR, character-level string access with negative index support, and automatic detection of optional tools at configure time.

OCR + language features
string[i] — character access by index including negatives
ocr->read(path, lang) · ocr->installed() · ocr->languages()
Automatic Tesseract discovery across 7 known paths on Windows, Linux, macOS
Tesseract and Ollama detection in CMake with per-platform install instructions
Phase 6 complete
Imports + Multi-flow + Functional Programming
Import system · func · closures · http-> · env()

The import system, multi-file architecture, and first-class functional programming. Functions as values, closures, recursion, higher-order functions, and the HTTP module for consuming external APIs.

Import system
import "./file.axon" — load agents and flows from external files
Circular import guard · private symbols via _prefix
Multi-flow: multiple flow {} in a project
Cross-flow referencing: FlowName.input · FlowName.version
Functional programming
Named functions: func name(params) { body }
Anonymous functions: func(params) { body }
Arrow syntax: (params) => expr
Closures — automatic capture of definition scope
Recursion · functions as values · higher-order functions
Nested functions with access to parent scope
HTTP + environment
http->get(url, headers) · http->post(url, body, headers)
http->json(url) — GET + automatic JSON parse
env("VAR") — read system environment variables
Phase 6B up next
Advanced Functional Programming
*args · **kwargs · selective imports · type annotations

The second layer of the functional programming system. Variadic functions, named arguments, tuple unpacking in loops, and selective imports to control what gets exposed between files.

In development
*args — variadic functions: func sum(*args) {}
**kwargs — named arguments: func log(**kwargs) {}
for key, val in dict — tuple unpacking
Selective imports: import "./f.axon" { fn1, fn2 }
Optional type annotations: (n: number) => n * 2
Generic any type for untyped parameters
Status: Designed and spec-complete. Implementation in progress on the C++17 interpreter.
Phase 5+ pending · waiting on API keys
API Providers + Multimodal
OpenAI · Anthropic · Cohere · Streaming · Vision

Same actor syntax, same validation contract, different provider. OpenAI, Anthropic and Cohere will work exactly like Ollama — no new syntax to learn.

Planned
Provider OpenAI — gpt-4o · gpt-4-turbo · gpt-3.5-turbo
Provider Anthropic — claude-sonnet · claude-opus · claude-haiku
Provider Cohere — command-r · embed-english-v3
HTTPS support in http-> via libcurl
Multimodal — images as LLM input (llava · gpt-4o · claude)
LLM response streaming · rate limiting · automatic retry per provider
Phase 7 planned
Native Fine-tuning
finetune {} · LoRA · llama.cpp · .gguf export

Train models directly from an Axon flow. Define a fine-tuning job as a block, point it at a dataset, and get a model file ready to load as an agent — without leaving the language.

Planned
finetune {} — training job definition block
LoRA fine-tuning via llama.cpp backend
Dataset formats: JSONL · CSV · TXT
Configurable train/validation split · checkpoints · real-time progress
Export to .gguf — load directly as an Axon agent
Native RAG pipeline support
Phase 8 vision
Distributed Mesh
ChaCha20 · Gossip protocol · Peer-to-peer · Consensus

What an operating system does for processes on one machine, the mesh does for agents across machines. Encrypted peer-to-peer communication, dynamic topology, and the Consensus module for collective decisions.

Vision
Ultrasonic mesh — ChaCha20-Poly1305 encrypted point-to-point channels
Gossip protocol for distributed orchestration across nodes
Agents running on multiple machines, same actor syntax
Dynamic topology — nodes join and leave in real time
Consensus module — collective decisions with traceable audit trail
RFC open: The Consensus module is in design. Contribute to the discussion →
v1.0.0 vision
General Release
Package managers · VS Code extension · Package registry

The stable, production-ready release. Full tooling ecosystem, package distribution via native package managers, and the official VS Code extension.

Vision
Package managers: winget · brew · apt
VS Code extension — syntax highlighting, autocomplete, inline errors
Axon package registry — axon install package-name
CLI extended: axon new · axon init · axon publish
Full interactive web documentation and playground