ARC - Autonomous Reasoning CLI

Inspiration

ARC started as a hackathon idea that never made it into an actual hackathon. We'd noticed the same failure pattern in every team project: the plan made at hour zero rarely survives contact with hour twelve, and by the time anyone notices a blocked dependency, hours of runway are already gone. My team ended up choosing a different idea to build — but the concept stuck with me. Most AI dev tools write code. I wanted to build one whose entire job was knowing when to say something, and knowing when to stay quiet. So I built it solo, one commit a day, over a month.

What it does

ARC is a CLI (and now a local GUI) that models a project's real state — milestones, git commits, risks, and its own past decisions — as a local knowledge graph. It watches your repo through a git hook, and every time something drifts from the plan, it runs the signal through a three-check intervention gate:

Materiality — does this actually block something real, via a dependency-graph traversal, not a flat heuristic?
Timing — is now the right moment to interrupt, or would it just be noise on top of an already-fired nudge?
Specificity — can it point to an exact file, commit, and dependency chain, or is it just a vague, trust-eroding guess?

Only if all three pass does it send a nudge. Every decision — fired or silent — is logged as its own graph node, so the reasoning is always inspectable after the fact, not a black box.

arc live then takes that whole graph and every CLI/SDK action and exposes it as an actionable, real-time local dashboard — Node-RED-style — that spins up on command and shuts itself down the moment you close the browser tab.

How we built it

Core: Python + Typer for the CLI, SQLite for a local, offline-first knowledge graph (typed nodes and typed edges — depends_on, touches, causes, decided_by, links_to).
Watching: a real git post-commit hook links every commit to the milestone it touches, no polling.
Reasoning: LLM calls generate the milestone graph, draft nudges, and power the gate's judgment — originally on the Anthropic API, later moved to a pluggable provider layer with local Ollama support for fully offline use.
The GUI: arc live runs a local FastAPI + WebSocket server so the graph, deadlines, and decision feed update live in the browser, with no separate backend service needed for self-hosted use.
I built and tested every module myself, using AI pair-programming tools for a meaningful part of the implementation while I drove the architecture, the schema design, and — most importantly — every test pass on the gate logic itself, since that's the one component where a bug (too chatty, or too silent) breaks the entire premise of the project.

Challenges we ran into

Designing the gate itself. Getting from "notify on any drift" to three independently justifiable checks took several rewrites — an early version fired on nearly everything, which defeats the whole point.
Switching LLM providers mid-build. Moving from Claude to a local Ollama model broke arc plan's strict JSON output reliability, which forced me to add much more defensive parsing than I'd originally planned for.
Git hook plumbing. Getting a post-commit hook to reliably call back into a Python CLI, across platforms, with clean failure handling when a commit matches no milestone, took more iteration than expected.
Making silence trustworthy. The hardest part wasn't the code that fires a nudge — it was proving, through actual testing, that the code that stays silent is staying silent for the right reasons.

What we learned

That an agent's credibility is built entirely on the decisions it doesn't announce. Also: a knowledge graph is a much better foundation for "explainable AI reasoning" than a flat table ever could be — being able to traverse depends_on edges is what makes the materiality check possible at all.