I got tired of AI agents lying about finishing work, so I built a daemon that makes them prove it

A local Rust daemon that refuses an AI coding agent’s “done” when the evidence does not match the claim, and writes every refusal to a tamper-evident audit log.

You let an AI agent code for you. It works for a while, then says “done.”

You open the diff. There is a TODO where the hard part was supposed to be. An unwrap() that will panic in production. A test that was “fixed” by being skipped. The build is green only because the failing case was commented out.

So you redo it yourself.

If you have worked with coding agents for more than a week, you know this loop. The agent is not malicious. It is optimizing for the appearance of completion, because that is what “done” rewards. The result is the same either way: the word “done” stops meaning anything, and you become a full-time reviewer of confident lies.

I got tired of it. So over the last few weeks I built Convergio.

The idea: do not trust the agent, make it prove the work

The idea: do not trust the agent, make it prove the work

Convergio is a local Rust daemon that sits between your agent runner and your codebase. It does one stubborn thing: when an agent tries to move a task to submitted or done, it runs the claim through a pipeline of server-side gates. If the evidence does not match the claim, the transition is refused with an HTTP 409, and the agent does not get to call it done.

The gates that ship today are not aspirations. They are code. No technical debt: refuses debt markers like TODO and FIXME across 7 languages. No scaffolding: refuses work that admits it is a stub, placeholder, or not wired yet. Zero warnings: refuses non-clean build, lint, and test signals. No secrets: refuses leaked credentials using a gitleaks-style pattern set.

Crucially, the gates live on the server side. The agent talks to the daemon over HTTP, and the routes cannot bypass the gates. There is no “trust me” path.

The part I actually care about: the refusal is provable

A gate that refuses work is useful. A gate whose refusals you can verify from the outside is something else.

Every refusal, and every other state transition, lands in a hash-chained audit log. Each entry is chained to the one before it, so you cannot quietly rewrite history. Delete or alter a row and the chain breaks, visibly. You can ask the daemon to verify the whole chain at any time, and it tells you exactly where it broke, if it did.

This turns the agent saying it is done into something verifiable: the system recorded that the agent tried to mark it done, the gate refused it for debt_marker_found, and here is the tamper-evident proof. It is the difference between a vibe and an audit trail.

What it is, and what it deliberately is not

Convergio is the execution and enforcement layer: plan, dispatch, audit, gate. It is not a model, and it never calls a raw API. It spawns your own vendor CLI: Claude Code, Copilot CLI, Qwen, Codex, Gemini, or a runner you define yourself. No API keys to hand over, no SaaS, no cloud. It is fully local, single-user, SQLite-only. There is no Convergio server to sign up for, because there is no Convergio server.

It is also not a planner. It composes with whatever produces a plan: a planning tool, your own script, or you typing the plan by hand.

It is young, and I would rather be honest than impressive

This is a personal open-source project, not a company and not a product launch. It is a few weeks old. Some of the five principles it is built around are fully enforced today: technical debt, scaffolding, internationalization. Others are partial or still planned, and the README marks each one explicitly so it never claims more than the code does.

That honesty is kind of the whole point. The thing I am building is a tool that refuses to overstate what was done. It would be absurd to oversell the tool itself.

Try it in 60 seconds

If you run AI agents and you are tired of done that is not done, the fastest way to feel what Convergio does is one command after install: cvg demo. It creates a deliberately dirty task, watches the gate refuse it with a 409, then runs a clean plan that passes and verifies the audit chain end to end.

The code is on GitHub: github.com/Roberdan/convergio

I would love feedback from people who have felt this exact pain, especially on which gate you would want next.

Convergio is a personal open-source project. It is not a Microsoft product and is not affiliated with or endorsed by Microsoft.