Blog
Notes from the build.
Deep dives into how the runtime actually works, covering the design decisions and the plumbing behind the product. Mostly written by the people who wrote the code.
Where the next run lives.
Hermes Agent and OpenClaw store the next run on the recurring job itself. We create a separate row for every occurrence. That difference explains most of the scheduler we ended up building, including several ways it failed.
EngineeringRecurring automation, measured.
We gave four agents the same plain-English automation requests, ran their schedules under the same conditions, and checked every delivery against the correct answer. We also counted every model call. The results include the experiments Unify lost.
EngineeringTwo brains, one voice.
A model smart enough to do the work is too slow to hold a phone conversation, and a model fast enough to hold the conversation cannot safely do the work. We run both and make them sound like one speaker.
EngineeringWhy we split skills into functions and guidance.
Most agent skills put scripts inside a document. We store executable functions and written guidance separately, then link them when they belong together. That lets one rule govern several functions without being copied into each one.
EngineeringThe conversation is not the work loop.
If you message an agent while it is working, most frameworks must queue the message, stop the task, or insert your words into the worker's transcript. We keep a separate loop available to handle the conversation while the work continues.
EngineeringFork the conversation, or go in cold.
“Send the report to Sarah” is clear only if the worker knows which report and which Sarah. Every delegated task therefore makes an explicit choice: inherit the conversation, or start with the request alone.
EngineeringThere is no demonstration mode.
You can show our assistant how to do something by sharing your screen and talking through it, and we never actually built a feature for that. It falls out of three things we'd already built for other reasons.
EngineeringAgents that pick up where they left off.
A task can return its result without throwing away its transcript or working state. You can correct it while it runs, answer a question from inside it, or continue the same work later.
EngineeringExecution is a coordinate, not a call.
A one-shot code tool forgets everything after each call. A persistent interpreter keeps too much and lets one task contaminate the next. We give the model an explicit choice of state, environment, and machine for every execution.
EngineeringModels are feedforward. Brains are not.
A language model cannot remember a previous call or change a call already in progress. Memory, interruption, and long-running work all come from the system around it. This is how we built that system, and where its complexity costs us.
Reading about it is the slow way round.
Starter credits, no card. Hand a droid one real job and watch what it does with it.