Classifier receipt

Hi all! This is the first dedicated post I am making about this project. I have mentioned it online a few times before, but I have never properly introduced it. After several months of work, its finally ready to be published, and I'm really excited! Caliper Harness is a coding harness that runs in your terminal. I built it for small local models. The basic idea is simple. A small local model on its own will rush, skip steps, and tell you something is done when it is not. So the harness does the disciplining for it. It makes the model plan first, get approval, work in checked steps, and prove things with tests and a separate review before anything counts as finished. Right now it is local only. You point it at a local model server and it works from there. If cloud API support is something a lot of people actually want, I will build it. For now, local is the focus. The way I test it is with a benchmark game. I give it an empty folder and tell it to build a small browser game, Space Transporter, from scratch. Then in later runs I ask for bigger and bigger features on top. I judge it on the final game quality and on the full traces of what the model actually did. The video attached to this post is the from scratch build, sped up a lot. It is a few hours of work, so you can pause and see how the harness looks and behaves. After that first build, I used the same game for a harder follow up run. I asked for a bigger feature as a stress test for the harness. I wanted the stations in the game to feel alive, with shortages and emergencies, and I wanted them to remember the player. Before writing any code, the model has to plan. It splits the work into a plan, an approach, and tasks. It writes out the staging, the trade offs, and the risks. I read that in the plan screen and approve it or send it back. Plans are built through a structured, step by step process called PAT (Plan, Approach, Task). PAT lives in a GraphQL state graph. A plan can have multiple approaches, and an approach has multiple tasks, with each level getting more specific and staying connected to the level above it. It is very time consuming for the model to build. In my testing though, the plans stay coherent from the high level stages all the way down to the small tasks. That structure also makes planning and execution much easier for a smaller model to manage. If there is a real decision to make, the model is pushed hard to ask instead of guessing. I have iterated on that behavior a lot. In this run it asked how fast station situations should change, how harsh a station that distrusts you should be, and how much of that state the game should show. Once the plan is ready, it claims one task at a time. Every task has its own check command from the project. A task only counts as complete when its check passes and an independent review also passes. The model does not get to decide it is finished just because it says so. Completion has to match what was written in the task during planning. After the checks, a fresh reviewer pass looks at the work with clean context. This part matters to me. It gives the work an adversarial review without carrying all the coding context into it. In this run, the first stage had every test green, and the reviewer still found a real bug. One of the six station situations was drawing with a broken colour, so it never showed on the map. The tests never caught it. The task got sent back, the model fixed it properly, added tests that fail on the old code, and only then did it pass. The harness does this automatically. But why? A lot of harnesses like OpenCode feel built around large intelligent models, token efficiency and speed. That makes sense for what they are trying to do. Caliper makes a different trade on purpose. It is slow and very deliberate. It makes the model plan, wait for approval, run checks, get reviewed, and fix things properly when it gets sent back. A small model that is left alone will cut corners. A small model inside this is forced to be diligent at the cost of speed. These runs took hours. I leave it running overnight and check the traces in the morning. For me, that trade is worth it, because the work that comes out is work I can trust a lot more. Part of how that works is the decision judge. It is a second, much smaller decision model that watches the main model while it works. It steps in at certain points, like when the model is stuck in a loop, failing the same way repeatedly, changing phase, failing recurringly at a tool call, or asking for a plan to be marked ready. It gives a simple judgement with a confidence score. Caliper can use that to steer the model, ask for a repair, or hold certain risky steps for approval. If the judge is slow or down, the work carries on and the outage just gets recorded. Between the judge, the planning structure, and the reviewer, a small local model ends up behaving a lot more carefully than it does on its own. Making small local models more capable through structure like this was a big part of the design. There are also some user facing features that ended up mattering a lot in day to day use: * There are 3 separate draft text boxes, so you can have 3 prompts being built at the same time and send them individually. This has been huge for me despite being so simple. Sometimes I am writing a massive continuation or expansion prompt, and the model does something ridiculously stupid that needs to be fixed immediately. I can keep the big prompt saved in one draft, switch to another draft for the urgent message, and keep a recurring status update prompt in the third one. All of it stays inside the harness. * `/btw` lets you inject a steering note into a run while the model is still working. I use it when I spot it heading in the wrong direction and I do not want to stop the whole run just to correct it. * You can browse and open files from across the project without leaving the harness. The Diff view follows model edits across files in real time, `/open-diff` opens a retained change, and `/changes` shows the recorded history for a file. With `/comment`, you can attach direct feedback to specific file lines, plans, approaches, tasks or documents and queue it for the model to address. Here is the rest of what is in v0.3.0: * Tabs for separate chats and screens for Chat, Diff, Plans, Plan, Library, Sessions, Decisions, Workflows, Files, Tests, Settings, Status, and Models & Servers * A plan screen with a short approval summary first, then drill down into the approach and each task * Versioned plan elaborations, so staging, trade offs and risks can be read and approved before coding * A workflow library. The model can browse and author reusable methods, then attach one to a claimed task as a method lens, using the same step-by-step isolated architecture as the planning mechanism. Caliper checks the library every time work is claimed * A `wait` tool, so the model can sleep and wake up when something finishes, like CI, instead of checking over and over * Local server detection for servers that are already running, including llama.cpp, Ollama, Rulith, MLX, vLLM and other OpenAI-compatible endpoints * Models & Servers management inside the TUI. You can add, edit, test, select, load and unload saved connections. There is also an assisted setup prompt you can copy if you want help wiring an existing install * Separate Coding and Judge roles, with human approval available if you switch the decision model off * Auth modes with `/auth`, plus `/tools` to switch between coding and full tool exposure * Project style rules with `/style`, shared by the coder and the reviewer, plus `behavior.md` for how the agent should conduct itself * Domain knowledge graphs for areas like testing, UI/UX and code design. The model can read linked sections as needed, and it can author project guides and record preferences into the same graph instead of loading everything into context at once * Project memory with `/remember` and `/recall`, including shared global notes if you ask for them. The model can also record useful project knowledge itself * Notices. While working, the model can save weak spots, brittle code and opportunities it notices, without turning them into surprise tasks * A Tests screen for designing, refining and running project test suites, with result history and test guidance built in * Full session records. Every reply, tool call, judgement, file effect and final outcome is saved. Past runs can be browsed, and decision judgements can be replayed from the CLI * Personal settings that carry across projects, with project config still able to override them * Headless `run` mode for scripts, a plain `chat` mode with no agent tools, and CLI access to sessions, judgments, plans, approaches, the GraphQL state graph, effective config and hardware limits * In app updates with `/update`, plus managed packages for macOS arm64, Windows amd64, and Linux amd64/arm64 One thing I still want to build next is a proper tool for turning normal Markdown skills into graph-compatible domain graphs or workflow graphs, using the same step by step style as PAT. That is planned for later, so I am not counting it as a v0.3.0 feature. It is still an early release and results depend a lot on the model you give it and what you're using it for. So far I have run it with Qwen3.8 Flash Next, Qwen3.8 27B, Laguna S 2.1, Gemma 4 26B, and a few others. I would really like feedback, especially from people running smaller local models. I am planning on running benchmarks comparing Caliper against other harnesses for both output quality and time cost, and I will post those when they are ready. This is a project I am actively working on and iterating, so feel free to give me some feedback or ideas and I'll implement them in the next version. Use it now! GitHub: [https://github.com/santiagoaraoz2001-sketch/caliper-harness](https://github.com/santiagoaraoz2001-sketch/caliper-harnes

Model stylome-1.2-large · recorded 2026-11-18T19:43:27.156068