Steer your autonomous engineer from chat: Kairos meets Hermes

Adopting an autonomous engineer is an act of trust that most teams are not ready to make — and rightly so. An agent that writes code, opens pull requests, and deploys to production is only useful if you can question it, redirect it, and refuse it. Until now, running Kairos meant getting the work without the conversation: commits appeared, decisions happened, and the only way to intervene was to stop the whole thing.

Today we're releasing the Kairos addon for Hermes, Nous Research's open-source personal agent. It lets you install, question, steer, and gate an autonomous engineer entirely from chat — Telegram, Discord, Slack, WhatsApp, Signal, or your terminal — on any Hermes configuration, with a single browser tap as the only moment that requires your hands on a keyboard.

We built this because we needed it ourselves. Kairos has been running against our own repositories for months: it reads issues and CI, decides what matters, writes the code, opens the PR, and verifies the deploy actually landed. The work was good. The trust was not — and everything in this release exists to close that gap.

The trust gap in autonomous engineering

Autonomous agents fail their users in a specific way: not by writing bad code, but by being unanswerable. When a colleague pushes a change you disagree with, you ask why, you push back, and sometimes you say no before it ships. Every one of those moves was missing.

Three questions define whether an autonomous engineer is a co-worker or a liability:

• Can you ask it why? Not a plausible explanation generated after the fact — the actual reasoning, from the moment the decision was made.
• Can you change its priorities without restarting it? Your view of what matters changes daily. The agent has to absorb that while it works.
• Can you say no before it acts? Pushing to main and opening PRs are exactly the actions a human should get to approve — without the agent grinding to a halt while it waits.

The Kairos addon answers all three, and it answers them from the chat app already in your pocket.

What is the Kairos addon for Hermes?

The addon is a capability package for any Hermes agent: a skill document that teaches Hermes the complete Kairos command surface, an unattended bootstrap that takes a machine from nothing to a running engineer, and a wire contract designed so an agent can recover from any failure on its own.

There is deliberately no plugin and no SDK. Hermes agents have terminals, so the entire integration is a CLI that speaks single-line JSON — which is what makes it work on any Hermes configuration, from a Docker deployment on a VPS to Termux on a phone, with zero coupling to Hermes internals and zero version dependency. Hermes is MIT-licensed and its skills system is an open standard; this addon is just a very disciplined citizen of it.

What's in the addon?

• Unattended bootstrap. One command takes a fresh machine through installation, prerequisites, memory setup, login, repository configuration, daemon start, and skill registration. Every step checks whether it is already done, so re-running after a failure continues instead of starting over.
• Status and explanation on demand. Ask what Kairos is doing and you get its live state. Ask why and you get the recorded reasoning behind its latest decision — what it chose, what it considered, and the reason, exactly as written down at decision time.
• Six steering verbs. focus, pin, ban, goal, pause, resume. Directives are absorbed while the engineer works, every one is resolved with a recorded reason, and none ever disappears silently.
• Approval gates. Risky actions — pushing, opening PRs — wait for a human answer while Kairos keeps working on everything else. Denials are recorded with your reason, permanently.
• A journaled history of every decision, directive, gate, and answer, queryable from chat.
• Errors written for agents. Every failure is a structured message with a hint field containing a runnable command. Your agent reads the hint, fixes the problem, and retries — without you.

How it works

Two walkthroughs show the shape of it.

Setting up from your phone. You message your Hermes:

set up kairos on the api repo

Hermes fetches the bootstrap and runs it. Progress streams live, so when the device-login moment arrives, Hermes relays it to you:

Kairos needs a one-time login — open https://backant.io/device and enter code KZT-42Q.

You tap approve in your browser. That is the only human moment in the entire setup. Hermes confirms each remaining step as it completes, and a few minutes later you have an autonomous engineer running against the repository. If any step fails — Docker not running, GitHub CLI not authenticated — Hermes receives a structured error naming the exact fix, applies it, and re-runs. The bootstrap continues from where reality says it should.

Approving a push from the couch. Later that day, Hermes pings you:

Kairos wants to push "fix flaky retry test in auth.spec.ts" to main. Approve?

You ask why. Hermes runs backant ctl explain --json and relays the recorded reasoning: CI has been red for two runs, and you told it this morning to focus on the flaky tests. You approve. The push executes.

One detail here matters more than it looks: if the repository changed while that gate was waiting — someone else pushed, the branch moved — your approval is refused and the action does not execute. A yes given to an old reality never applies to a new one. Kairos re-proposes against the current state instead.

Built to be trusted

Three properties run through everything above.

Answers are records, not reconstructions. When you ask why, nothing generates a fresh explanation. You get what was written down when the decision happened, or an honest "not recorded." There is no model anywhere in the answering path — your agent interprets, Kairos supplies facts.

No is as durable as yes. Every denial, every overridden directive, every refused stale approval is journaled with its reason. "Why did you say no last Tuesday" has an answer.

Everything stays on your machine. The steering state — directives, gates, decisions, history — lives in a local per-repository store. Nothing about your decisions leaves the machine the engineer runs on.

What's next

The same steering surface is coming to two more places: backant tui, an interactive terminal view for when you are at your desk, and a live dashboard here on backant.io with a card for every running engineer. Both speak the same contract the Hermes addon uses today.

Before we call this generation done, it has to pass what we call the stranger test: a fresh machine, a real Hermes, nothing but the bootstrap command — and a full session of setup, questions, steering, and approvals with zero human keyboard time beyond the device tap. The runbook ships in the repository, and we run it on every release.

Try it today

You can start now. You need macOS or Linux, Claude Code, the GitHub CLI, Docker, and a Kairos subscription at backant.io. With Hermes installed, send it one message:

run npx --yes backant-kairos@latest hermes bootstrap in ~/code/your-repo
and follow the hints. send me the device login link when it appears.

Then ask it what Kairos is working on. Ask why. Tell it what matters this week. Say no when it should hear no.

If you want the addon to handle something it doesn't yet, open an issue — the steering surface grows in the direction people pull it.