Axiom

Approve Tasks
Check your files
Monitor Work
Watch the dataflow

Axiom is a human-controlled AI engineering harness. It helps a product owner turn intent into a bounded engineering task, lets an isolated AI developer implement it, and returns the evidence needed for a human to decide whether to merge, revise, or stop.

⚡ Instant Interactive Demo (No Login Required)

Evaluate Axiom directly in 5 seconds without setting up Supabase, OAuth, or Docker:
🚀 Try Guest Demo →
(Simulates real-time task lifecycle, AI validation gates, and continuous packet-by-packet harness telemetry)

Live application: axiom-ruddy-three.vercel.app

Built by Axiom 🚀

PulseBoard (Live Demo) — A complete product created entirely by Axiom alone!

Note: Axiom currently primarily supports React applications.

Inspiration

As a modern developer, I kept hitting the same wall with AI: I knew what I wanted, but not always how to prompt it. Sometimes I would rewrite the same request five different ways. Sometimes I did not know what to ask next, whether the AI understood the project, or whether I was even heading in the right direction. This is even more frustrating when I am away from my desk and trying to move a project forward from my phone. I wanted an AI software-engineer partner that understood the project over time: one that could suggest the next move, explain its reasoning, and turn my intention into real work. But I do not think an AI developer should be fully autonomous. I still want to make the product decisions and approve what ships. That is the idea behind Axiom: an AI engineering harness that stays under my control.

What it does

Axiom turns a product request into a bounded, reviewable code change. I give Axiom a request in plain language. It uses the project context to propose a concrete task: what needs to change, which files it may touch, how it should validate the result, and what “done” means. After I approve it, Axiom runs an AI developer in an isolated Docker workspace. The developer works on a dedicated Git branch, uses tools to inspect and change the codebase, runs validation commands, and returns the work for review.

How we built it

I built Axiom as a Next.js application with Supabase for authentication, project data, task state, and the audit trail. GitHub connects the product to a real repository and gives every task its own branch. The execution environment runs in Docker so each task starts in a fresh workspace rather than directly touching the developer’s machine or main branch. The AI developer has a set of controlled tools for reading files, writing permitted files, running commands, checking changes, and finishing a task with a report. I used Google’s Gemini API and function calling inside the runtime harness to let the developer model choose tools and iterate on a task. I also used Codex with GPT-5.6 throughout almost the entire build: planning the architecture, challenging decisions, debugging issues, designing the UI, writing implementation plans, and implementing large parts of the project alongside me. Codex was not just used to generate isolated snippets. It was part of the development loop while I built the system meant to improve that same loop.

Challenges we ran into

The hardest challenge was getting the AI to generate accurate implementation work without letting cost grow uncontrollably. More context can improve an agent’s decisions, but sending an entire repository on every step is expensive and noisy. I had to find a balance: give the agent enough project understanding to make good decisions, while limiting the files, tool calls, retries, command runtime, and model usage for each task. Other challenges included: Keeping a task scoped so it does not turn into an accidental refactor. Building a reliable tool-calling loop instead of accepting vague model output. Running code safely in a disposable Docker workspace. Handling failed commands, invalid tool calls, rate limits, and retries. Making the human approval step meaningful rather than just decorative.

Accomplishments that we're proud of

I am proud that I built a working coding harness from scratch, not just a chat interface around an AI model. Axiom can connect project context to a real coding workflow: plan a task, create an isolated workspace, let an AI developer use tools, make the change on a branch, run checks, and bring the result back to the human.

What we learned

I learned to stop planning forever and start implementing. During a hackathon, it is easy to chase the perfect architecture, perfect prompt, or perfect design. Building Axiom taught me that a working product teaches more than a polished plan ever can. I learned to make a decision, build the smallest version that proves it, test it, and improve it from there. I also learned that AI is most useful when it has clear boundaries. Better models matter, but good context, useful tools, scoped tasks, and honest human oversight matter just as much.

What's next for Axiom

The demo proves the core loop: Axiom can take a request and turn it into real implementation work. Next, I want to improve the prompting, context selection, harness reliability, and task-planning algorithms. I want Axiom to understand a project more deeply while staying efficient with API usage and remaining clear about what it is doing. Longer term, I think this could become a developer tool of its own—or a strong harness that can sit behind other coding agents. The goal is not to claim that AI can replace engineers. The goal is to make AI development feel less like repeatedly guessing the right prompt, and more like working with a capable engineering partner that stays under your hand.