u/The_guy_withnolife

Hi everyone,

I wanted to introduce Axiom, a desktop AI assistant for Windows that focuses on running language models locally. It uses llama.cpp/LlamaSharp to load GGUF models on your own hardware, so conversations stay on your machine. There is an optional cloud mode if you want to use bigger models with your own API key, but it isn’t required.

Axiom has two modes: a normal chat mode and a "Workplace Council" pipeline. The council splits a task across three roles — Architect plans the work, Builder produces the output, and Critic reviews and suggests improvements. Between steps it runs static checks and sandboxed Python/Java code, and shows a diff of what changed. It’s designed for iterative tasks where one agent isn’t enough.

Beyond that, the app can analyze documents you attach, render LaTeX/math, and run basic web searches. It’s open source and licensed for non‑commercial use. If you're curious to try it or see the code, I'll drop a GitHub link in the comments.

Feedback on the workflow or features is welcome!

I've been working on a local AI app called Axiom for a while and finally put out a pre-release, I wanted to share the architecture honestly rather than just posting a feature list.

What it actually does

The core idea is role isolation. Instead of one model handling planning, execution, and self-review simultaneously — which models are genuinely bad at, since the same weights that produced an error are being asked to catch it — the pipeline separates these into three structurally distinct roles with hard boundaries.

The Architect receives the decomposed problem and outputs only a numbered step-by-step plan. Its system prompt explicitly forbids code and prose — just concrete numbered actions. It terminates with a literal handoff token. The Builder receives that approved plan and implements it, adapting its output format to the task type: executable code for coding tasks, natural language math for calculation tasks, structured prose for research and analysis. The Critic receives both the Architect's plan and the Builder's output simultaneously and checks one against the other — not against its own judgment, but against the plan that was approved before the Builder ran.

These aren't three attempts at the same question. They're three different functions that a single model call normally collapses together.

Hardware floor

Realistically: 8GB RAM runs smaller models through the pipeline. 16GB gives you comfortable headroom for 7B-class models. The app is Windows-only — WPF, .NET 10. No Mac, no Linux currently.

Free cloud mode

If you don't want to run local inference, there's an OpenRouter mode that runs the same full pipeline through their free models — same Architect/Builder/Critic structure, same validation, just cloud inference instead of local. Free with an API key. Good way to test whether the pipeline is useful before committing to local model management.

What I'm genuinely uncertain about

Whether the sequential single-Critic design is the right call versus multiple review cycles. The current reasoning is that a second Critic pass after revision creates diminishing returns and adds significant latency, but I'd be curious if anyone has experimented with this in their own pipelines.

Also whether the drift detection weighted scoring is the right approach for role enforcement with sub-4B models or whether there's a better mechanism.

MIT licensed, free, no telemetry. Repo is at github.com/YoMosa2009/Axiom. Happy to go into detail on any part of the architecture