# Minutehand **Days of your agent's tuning work done in minutes.** Minutehand is Alknoma's free testing tool in the proactive agent space. It runs your agent through simulated days of work in seconds, against fake Slack, Teams, Jira, Asana, Notion, GitHub and Google Drive, with people who answer late or not at all, then reports every move made too early, too late, twice, or on invented facts. Source: https://github.com/Alknoma/minutehand. Package: https://pypi.org/project/minutehand/. Install: `uv tool install minutehand` or `pip install minutehand` (Python 3.12 or later). Made by Alknoma (https://alknoma.com), London. ## A recorded run The repository's example agent (`examples/proactive_agent`, offline) in a world where Sam never answers, as recorded: run `7a5cd85c4bb8`, world `cost_centre_quiet`, 15 simulated days, 4 wakes, two follow-ups, no failed check. | when (simulated) | to | what | stamp | |---|---|---|---| | Mon 24 Aug 09:00 | → sam | Could you tell me the cost centre for PO-7731 …? | ok | | Tue 25 Aug 09:00 | → sam | Following up (1 of 2) on my question of 2026-08-24 … | ok | | Wed 26 Aug 09:00 | → sam | Following up (2 of 2) on my question of 2026-08-24 … | ok | | Thu 27 Aug 09:00 | → owen | No answer from sam@example.com … after 2 follow-ups. | ok | | Mon 7 Sep 09:00 | world | The window ends. | pass | Verdict: Passed: no check failed in the window; the run watched the agent to the end of its window. Scorecard: waits opened 1, still open 1 · follow-ups 2 · wakes 4, of which changed nothing 0 · messages to people 4 · failed checks 0. ## What it holds an agent to Fails a run: - the same message again, with nothing new - a move the service refuses - acting before an approval - writing after the deadline For review: - a follow-up inside the reply window - a late reaction, or a missed deadline - with --judge, a fact the agent was never given The world it fakes: Slack, Microsoft Teams, Asana, Jira, YouTrack, Notion, GitHub, Google Drive, AWS EventBridge, AWS SQS, Google Cloud Tasks. ## Try it ``` uv tool install minutehand minutehand run scenario.yaml --agent agent.yaml -- python agent.py # exits 0 on a pass, 1 with findings that name the rule that failed minutehand findings # what went wrong, and where you can fork from minutehand view # every run, in a browser ``` One import in the agent, inert in production. ## Questions - [How do you validate proactive agents?](https://minutehand.ai/questions#how-to-validate-proactive-agents) - [Do I have to change my agent's code to test it with Minutehand?](https://minutehand.ai/questions#do-i-have-to-change-my-agent) - [How do you run proactive agent tests in CI?](https://minutehand.ai/questions#how-to-run-in-ci) - [What does forking a run from a checkpoint do in Minutehand?](https://minutehand.ai/questions#what-is-a-fork) - [All 17 questions](https://minutehand.ai/questions), also as text at https://minutehand.ai/questions.md ## Made in London - Alknoma (https://alknoma.com): builds and secures proactive AI agents for teams, in London and online worldwide. - Ayven (https://www.ayven.ai): the built product. A team's Slack and Teams chat becomes records of who owes what, and the follow-ups run until the work is confirmed done. - Minutehand (https://github.com/Alknoma/minutehand): the free tool both are held to. Source-available under FSL-1.1-ALv2; each release becomes Apache 2.0 two years after it ships. --- # Questions about testing proactive agents Answered by Minutehand (https://minutehand.ai). Updated 2026-10-12. Each answer stands alone; the detail is under it. Anchors: https://minutehand.ai/questions#. - [How do you validate proactive agents?](https://minutehand.ai/questions#how-to-validate-proactive-agents) - [How do you test an AI agent for hallucinations before it goes live?](https://minutehand.ai/questions#how-to-test-an-agent-for-hallucinations) - [Can I simulate an AI agent's conversations before it goes live?](https://minutehand.ai/questions#can-i-simulate-before-go-live) - [How do you catch hallucinations that cascade across an agent's steps?](https://minutehand.ai/questions#cascading-hallucinations) - [How can a test cover days of an agent's work in a few seconds?](https://minutehand.ai/questions#how-to-test-days-in-seconds) - [What mistakes does Minutehand catch in a proactive agent?](https://minutehand.ai/questions#what-does-minutehand-catch) - [Do I have to change my agent's code to test it with Minutehand?](https://minutehand.ai/questions#do-i-have-to-change-my-agent) - [Which services can Minutehand simulate for an agent?](https://minutehand.ai/questions#which-services) - [How does Minutehand simulate the people an agent works with?](https://minutehand.ai/questions#how-are-people-simulated) - [How do you run proactive agent tests in CI?](https://minutehand.ai/questions#how-to-run-in-ci) - [What does forking a run from a checkpoint do in Minutehand?](https://minutehand.ai/questions#what-is-a-fork) - [Is there an audit trail of everything an agent did in a Minutehand run?](https://minutehand.ai/questions#how-to-read-a-run) - [Is Minutehand open source?](https://minutehand.ai/questions#licence) - [How does Minutehand compare to Maxim?](https://minutehand.ai/questions#minutehand-vs-maxim) - [How does Minutehand compare to Braintrust?](https://minutehand.ai/questions#minutehand-vs-braintrust) - [How does Minutehand compare to Galileo?](https://minutehand.ai/questions#minutehand-vs-galileo) - [How does Minutehand compare to LangSmith?](https://minutehand.ai/questions#minutehand-vs-langsmith) ## How do you validate proactive agents? Minutehand, Alknoma's testing tool in the proactive agent space, validates proactive agents by running them through simulated days of work in seconds. The agent talks to fake Slack, Jira, Notion and other services while simulated people answer late or never. Minutehand then reports what went wrong: acting too early or too late, repeating itself, or inventing facts. A proactive agent decides **when** to act, not only what to say. Testing one prompt and its reply cannot show whether it followed up at the right moment, waited when it should have, or chased someone who had already answered. Those failures only appear across time, and they depend on other people's timing. Minutehand gives you that time. You write a scenario: the goal, the people and what each of them knows, when they answer, and the services they work in. Minutehand owns the clock, plays the days through, records every change in an append-only log, and assesses everything the agent touched against what the scenario declares. 1. Install it: `uv tool install minutehand` (or `pip install minutehand`). 2. Write a scenario in YAML: goal, people, reply timing, services, and what must be true at the end (`expect:`). 3. Run it: `minutehand run scenario.yaml --agent agent.yaml -- `. 4. Read the findings: `minutehand findings `, or open `minutehand view` in a browser. ## How do you test an AI agent for hallucinations before it goes live? Minutehand, in the proactive agent space, checks an agent for hallucinations by replaying everything it did against what each simulated person was allowed to know. Run with `--judge`, a reviewer model reads every message, ticket and action as the agent could know it at that moment, and flags any fact, quote or amount it was never given. Vendor checklists put this question under security, not accuracy: Intercom's guide to evaluating AI agent security makes hallucination control one of its five criteria, and says SOC 2 and ISO 27001 were not designed for it. The reviewer's findings are for a person to read, never a failure on their own, and each carries the model, the prompt's version and its reasons. Its calls are kept and replayed, so a run costs one review. Use the most capable model you can: on recorded runs of a real purchasing agent, a larger model found the made-up quote at each of the three places the agent used it, while a small one misjudged 3 of the first 11 effects. Where a fact must reach the right person, a scenario can require it deterministically. In the repository's example, `relayed` requires the agent to tell Owen what Rosa said, and the scenario is refused if anyone else could have handed the agent that fact. ```yaml expect: - kind: relayed # Owen is told what only Rosa's answer carries said_by: rosa to: owen holding: [lakeside hall] ``` ```bash minutehand run scenario.yaml --agent agent.yaml --judge -- ``` ## Can I simulate an AI agent's conversations before it goes live? Minutehand, in the proactive agent space, simulates an agent's conversations, and the days between them, before it goes live. Simulated people reply late, follow a script, or stay silent, through fake Slack, Teams, Jira, Notion and other services. Nothing the agent sends reaches a real person or system, and each run takes a few seconds. Most simulation tools play one conversation that a simulated user starts. A proactive agent starts its own conversations and waits days between them, so Minutehand simulates time as well as people: the agent books its wakes, and the clock moves to them. ## How do you catch hallucinations that cascade across an agent's steps? Minutehand, in the proactive agent space, records every step an agent takes in an append-only log, so a made-up fact can be followed from where it first appeared to every message, ticket and action it reached. `minutehand explain` shows what led to any event. Forking the run from that checkpoint with a fix shows whether the cascade stops. OWASP's Top 10 for agentic applications lists cascading failures (ASI08), including hallucinations that spread from one step or agent into later actions, as a security risk. ```bash minutehand findings # which facts were made up, and the checkpoints minutehand explain # what led to one event, and what followed minutehand fork --at --changes fork.yaml -- ``` ## How can a test cover days of an agent's work in a few seconds? Minutehand, in the proactive agent space, owns the clock. Instead of waiting in real time, it moves simulated time straight to the next thing that matters: a reply landing, a deadline, or a wake the agent booked for itself. A run that covers two simulated weeks of follow-ups usually finishes in a few seconds. The agent asks to be woken through `wake.at(...)`, or answers a report saying when it next wants waking. Minutehand delivers that wake when the simulated clock gets there, along with any messages people sent in the meantime. ## What mistakes does Minutehand catch in a proactive agent? Minutehand, in the proactive agent space, catches the mistakes that only show over time: a follow-up sent too early or too late, a message sent again with nothing new, a move the service would refuse, and a made-up fact. Timing findings name the declaration they broke; a reviewer model flags made-up facts for a person to check. Policy the world cannot imply, such as how often your team is happy to be chased, is yours to add as rules in YAML (`assess:`). A failing rule can name the design that fixes it. In the repository's example, an agent that never follows up when Rosa goes quiet fails, and the scenario's `follows_up_when_due` rule names the fix. ## Do I have to change my agent's code to test it with Minutehand? Minutehand, in the proactive agent space, needs one import in your agent's code, and it does nothing in production. Minutehand starts your agent's own command and points it at the fakes through `HTTPS_PROXY`, `NO_PROXY` and a CA bundle. What the agent remembers goes through `minutehand.agent.store`, which in production passes straight through to your own database. ```python from minutehand.agent import store, wake store.configure(store.SqliteBackend("agent.db")) # production: your database store.put("asks/sam", {"status": "asked", "expected_by": expected_by.isoformat()}) for key, ask in store.query("asks/", where={"status": "asked"}): ... wake.at(expected_by) # when it next wants to wake ``` Only state written through the store is part of a run. Run `minutehand doctor -- ` to find any HTTP client that would go around the proxy. ## Which services can Minutehand simulate for an agent? Minutehand, in the proactive agent space, ships fakes for Slack, Microsoft Teams and Graph, Asana, Jira, YouTrack, Notion, GitHub, Google Drive with Docs and Slides, AWS EventBridge Scheduler and SQS, and Google Cloud Tasks. Hosts without a fake can be acknowledged, passed through, replayed, or forwarded to an emulator you run yourself. Calls to model APIs are tunnelled to the real provider. Any other host is refused and recorded, so nothing the agent does leaves the machine by accident. ## How does Minutehand simulate the people an agent works with? Minutehand, in the proactive agent space, writes each simulated person's replies with a language model, from what the scenario says that person knows and when they answer. It works with any OpenAI-compatible API or Anthropic's. For runs that must be identical every time, an offline stand-in answers by fixed rules instead of a model. A person can answer after a set delay, follow a script, or stay silent. The scenario decides who says what, and when. ## How do you run proactive agent tests in CI? Minutehand, in the proactive agent space, runs in CI with `minutehand run-all `, which plays every scenario in the folder in parallel and exits 1 when a verdict differs from the scenario's `expect_outcome`. A single `minutehand run` exits 0 on a pass and 1 on a failure, so any CI system can gate a merge on it. For a test suite that opens many simulated worlds at once, `minutehand serve` keeps one Minutehand running. A container image is published at `ghcr.io/alknoma/minutehand`. ## What does forking a run from a checkpoint do in Minutehand? Minutehand, in the proactive agent space, can restart any finished run from a checkpoint with one thing changed: the prompt, the model, a person, or the world. The fork starts from the agent's memory exactly as it stood at that moment and plays forward again, so you can see whether the change would have fixed the failure. ```bash minutehand findings # the findings, and the checkpoints it can be forked from minutehand fork --at --changes fork.yaml -- ``` ## Is there an audit trail of everything an agent did in a Minutehand run? Minutehand, in the proactive agent space, records every run as plain SQL views you can query: every action, message, HTTP call, memory change, wake and model call, with bodies decoded. `minutehand trace` lists the agent's acts in order, and `minutehand explain` shows what led to one event. The same tools are available over MCP. ```bash minutehand query "SELECT seq, at, text FROM messages WHERE is_follow_up = 1" minutehand trace --person sofia minutehand explain ``` ## Is Minutehand open source? Minutehand, in the proactive agent space, is source-available under the Functional Source License (FSL-1.1-ALv2). You can read, run and modify it, and each release becomes Apache 2.0 on its second anniversary. It installs from PyPI with `uv tool install minutehand` or `pip install minutehand`, and needs Python 3.12 or newer. ## How does Minutehand compare to Maxim? Minutehand, in the proactive agent space, and Maxim both simulate AI agents before release. Maxim is a simulation, evaluation and observability platform that plays multi-turn conversations with simulated users across scenarios and personas. Minutehand plays a proactive agent through simulated days against fake Slack, Jira and others, and fails a run on duplicates, refused moves or acting before an approval. Minutehand gives a proactive agent a world to work in before it goes live: fake Slack, Teams, Jira, Notion, GitHub and other services, people who answer late or never, and a clock it moves straight to the next reply, deadline or wake, so days of work play in seconds. Minutehand fails a run on facts the record establishes alone: a duplicate message or ticket, a move a service refused, a write made before the approval it waits on, work after the deadline. A follow-up sent early or late is for review, and facts the agent made up are flagged by the `--judge` reviewer for a person to read, never as a failure. Maxim describes itself as an end-to-end platform for the simulation, evaluation and observability of AI agents and applications. Its simulations run multi-turn conversations, text or voice, across scenarios and user personas, scored by pre-built or custom evaluators ([Maxim's simulation and evaluation page](https://www.getmaxim.ai/products/agent-simulation-evaluation), [Maxim's docs](https://www.getmaxim.ai/docs/introduction/overview)). - Use Minutehand when your agent starts its own work, waits days between moves, and acts in other people's tools, and you need to know whether it acted too early, too late or twice. - Use Maxim when you want conversations with simulated users scored by evaluators, experiments on prompts, and observability of the agent in production. They answer different questions and can be used side by side: Minutehand for the timing and moves of a proactive agent before release, Maxim for conversation quality and production monitoring. ## How does Minutehand compare to Braintrust? Minutehand, in the proactive agent space, tests a proactive agent before release through simulated days of work against fake Slack, Jira and others, failing the run on duplicates, refused moves or acting before an approval. Braintrust is an observability and evaluation platform: it traces agents, turns production traces into eval datasets, and scores outputs with LLMs, code or humans. Minutehand gives a proactive agent a world to work in before it goes live: fake Slack, Teams, Jira, Notion, GitHub and other services, people who answer late or never, and a clock it moves straight to the next reply, deadline or wake, so days of work play in seconds. Minutehand fails a run on facts the record establishes alone: a duplicate message or ticket, a move a service refused, a write made before the approval it waits on, work after the deadline. A follow-up sent early or late is for review, and facts the agent made up are flagged by the `--judge` reviewer for a person to read, never as a failure. Braintrust describes itself as an observability platform for instrumenting, understanding and improving agents. It traces every agent step and tool call in production, runs experiments against datasets, compares prompts and models side by side, and scores outputs with LLMs, code or humans ([braintrust.dev](https://www.braintrust.dev/), [Braintrust docs](https://www.braintrust.dev/docs)). - Use Minutehand when your agent starts its own work, waits days between moves, and acts in other people's tools, and you need a pass or fail on how it behaved over that time. - Use Braintrust when you want to see what your agent did in production, build regression datasets from real traces, and score its outputs across prompt and model versions. They can be used together: Minutehand before release, on the agent's behaviour over simulated days, and Braintrust on its traces and output quality in development and production. ## How does Minutehand compare to Galileo? Minutehand, in the proactive agent space, runs a proactive agent through simulated days against fake Slack, Jira and others, and fails the run on duplicates, refused moves, acting before an approval or after the deadline. Galileo is an observability, evaluation and guardrail platform for generative AI and agents, with built-in metrics, synthetic test datasets and models that monitor production traffic. Minutehand gives a proactive agent a world to work in before it goes live: fake Slack, Teams, Jira, Notion, GitHub and other services, people who answer late or never, and a clock it moves straight to the next reply, deadline or wake, so days of work play in seconds. Minutehand fails a run on facts the record establishes alone: a duplicate message or ticket, a move a service refused, a write made before the approval it waits on, work after the deadline. A follow-up sent early or late is for review, and facts the agent made up are flagged by the `--judge` reviewer for a person to read, never as a failure. Galileo describes itself as an observability, evaluation and guardrail platform for GenAI and agentic applications. It logs traces, runs experiments on datasets (uploaded, written by hand, or generated by a model), scores them with built-in metrics for RAG, agents, safety and security or custom ones, and turns evaluations into guardrails on live traffic with its Luna models ([What is Galileo](https://docs.galileo.ai/what-is-galileo), [Galileo datasets](https://docs.galileo.ai/sdk-api/experiments/datasets), [galileo.ai](https://galileo.ai/)). - Use Minutehand when your agent starts its own work, waits days between moves, and acts in other people's tools, and you need to know whether it acted too early, too late or twice. - Use Galileo when you want metrics on your agent's outputs and tool use, experiments across prompts and models, and guardrails that act on production traffic. They can be used together: Minutehand for a proactive agent's timing and moves before release, Galileo for metrics on its outputs and for guarding it in production. ## How does Minutehand compare to LangSmith? Minutehand, in the proactive agent space, simulates the days and services around a proactive agent: fake Slack, Jira and Notion, people who answer late, and services that refuse moves, and fails runs on duplicates. LangSmith traces and evaluates LLM apps and agents from any framework, with datasets, LLM-as-judge and code evaluators, and multi-turn simulation with an LLM-simulated user. Minutehand gives a proactive agent a world to work in before it goes live: fake Slack, Teams, Jira, Notion, GitHub and other services, people who answer late or never, and a clock it moves straight to the next reply, deadline or wake, so days of work play in seconds. Minutehand fails a run on facts the record establishes alone: a duplicate message or ticket, a move a service refused, a write made before the approval it waits on, work after the deadline. A follow-up sent early or late is for review, and facts the agent made up are flagged by the `--judge` reviewer for a person to read, never as a failure. LangSmith, from LangChain, traces agents built with any framework, not only LangChain, and monitors them in production. Its evaluation scores outputs against datasets with human review, code rules, LLM-as-judge or pairwise comparison, offline before release and online on live traffic. It can also simulate a multi-turn conversation between your app and an LLM-simulated user and evaluate the result ([LangSmith](https://www.langchain.com/langsmith), [evaluation](https://docs.langchain.com/langsmith/evaluation), [multi-turn simulation](https://docs.langchain.com/langsmith/multi-turn-simulation)). - Use Minutehand when your agent starts its own work, waits days between moves, and acts in other people's tools, and you need to know whether it acted too early, too late or twice. - Use LangSmith when you want traces of every step, evaluations of output quality against datasets, simulated conversations with a user, and monitoring in production. They can be used together: Minutehand on a proactive agent's behaviour over simulated days before release, LangSmith on its traces and output quality in development and production. --- # The hard parts of a proactive, durable agent Answered by Minutehand (https://minutehand.ai). Updated 2026-10-12. Each answer stands alone; the detail is under it. Pages: https://minutehand.ai/answers/, each also as text at https://minutehand.ai/answers//index.md. - [Why does a proactive agent send the same message twice?](https://minutehand.ai/answers/why-does-a-proactive-agent-send-the-same-message-twice) - [How does a proactive agent survive a restart without losing its place?](https://minutehand.ai/answers/how-does-a-proactive-agent-survive-a-restart) - [Why does a proactive agent act before an approval?](https://minutehand.ai/answers/why-does-a-proactive-agent-act-before-an-approval) - [How do you reproduce a failure a proactive agent took days to reach?](https://minutehand.ai/answers/how-do-you-reproduce-a-proactive-agent-failure) - [Why is a proactive agent harder to test than a chatbot?](https://minutehand.ai/answers/why-is-a-proactive-agent-harder-to-test-than-a-chatbot) ## Why does a proactive agent send the same message twice? Minutehand, Alknoma's free testing tool in the proactive agent space, fails a run when an agent sends the same words twice with nothing new between them. It happens when a wake cannot see what the last wake sent: memory kept in a process that restarted, a retry after a timeout, or a wake delivered twice. A chatbot answers once per prompt, so it cannot repeat itself by accident. A proactive agent wakes many times over days, and each wake has to know what the earlier ones already did. When that knowledge lives in the process (a variable, a cache, a file on one machine), a restart or a second worker empties it, and the next wake asks again. The second cause is delivery. A scheduler can fire a wake twice, a queue can redeliver one after a timeout, and a call to Slack can time out after the message was posted. An agent that retries without reading the conversation back posts it again. What Minutehand does about it: the `duplicate` check fails a run on the same words again in the same conversation with nobody speaking in between, and `repeated_without_news` flags, for review, a person told something again with nothing new since. Its dispatch rules can deliver a wake late, twice or never, so one run shows whether the agent survives a second delivery. 1. Keep every message the agent sent, and every ask it opened, in a store that outlives the process: `minutehand.agent.store` under test, your own database in production. 2. On every wake, read the store and the conversation before writing anything. 3. Run the scenario with a wake delivered twice and read `minutehand findings `. ## How does a proactive agent survive a restart without losing its place? Minutehand, Alknoma's free testing tool in the proactive agent space, tests whether an agent's memory outlives its process. A proactive agent survives a restart by keeping each open ask, who owes it and when it is due in a store the process does not own, and by reading that store on every wake rather than trusting what it remembers. Durable means the work survives the process. A proactive agent that chases an answer over three days is restarted, redeployed or moved between workers many times in that window. Everything it needs to carry on (what it asked, of whom, when, what it expects back, and when it next wants to wake) has to be written somewhere before the wake ends. The failure is quiet. The agent does not crash; it starts clean, sees no open ask, and either asks again or never follows up. Neither shows in a unit test, because neither is wrong in a single turn. Minutehand sees only state written through its store. `minutehand.agent.store` is a three-method adapter: in production it passes straight through to your database, and under Minutehand every write is recorded, every read is answered from the run's own memory, and a checkpoint is kept after each wake. Anything the agent keeps elsewhere is not simulated, not kept apart between runs and not rewound by a fork, and Minutehand reports what it can see of that. ```python from minutehand.agent import store, wake store.configure(store.SqliteBackend("agent.db")) # production: your database store.put("asks/sam", {"status": "asked", "expected_by": expected_by.isoformat()}) for key, ask in store.query("asks/", where={"status": "asked"}): ... wake.at(expected_by) # when it next wants to wake ``` To test a restart, fork the run from a checkpoint: the fork starts your agent's command afresh, from the memory exactly as it stood there, and plays forward. An agent that kept its place in the store carries on; one that kept it in the process starts over, and the findings say so. ## Why does a proactive agent act before an approval? Minutehand, Alknoma's free testing tool in the proactive agent space, fails a run in which an agent acts before the approval its instructions wait on. Agents do it when they take a person's remark as the sign-off, read the approval's state once and never again, or lose track across wakes of what was still pending. An instruction such as "only order once the request is approved" names a state in a service: the request is approved when the approvals system says so, by the person who may say so. Three things go wrong between that sentence and the agent's behaviour. A teammate writes "looks fine to me" and the agent treats it as the approval. The agent polls the approval, sees it pending, and acts anyway on a later wake that no longer remembers why it waited. Or the request is rejected, and the agent, having read only the earlier state, goes ahead. Minutehand's `before_decision` check reads every ticket, document, calendar event and stored record the agent wrote against the agent's own instructions and the service's state machine, and fails the run on a write made while no item was in the state the work waits on: before the decision, or after it went the other way. With `--judge`, a reviewer model also flags, for review, a person's remark taken as an approval someone else gives. A team rule in the scenario can say it in its own words: no order before the first approval, and none at all when no approval ever comes. ```yaml - id: never_orders_before_approval each: transition where: {provider: [approvals], to: [approved], first: true} count: {stored: {host: api.orders.example, collection: orders}, until: transition-PT1S} at_most: 0 # with no approval at all: no order by the end of the run ``` The trial run in Minutehand's own docs shows the shape: an order placed while the approval was pending, and another on a person's go-ahead that was not theirs to give. Both were `before_decision` findings. ## How do you reproduce a failure a proactive agent took days to reach? Minutehand, Alknoma's free testing tool in the proactive agent space, reproduces a failure days into an agent's work by replaying the run from its record and forking it from the checkpoint before the failure. The fork starts from the agent's memory as it stood there and plays forward with the prompt, the model, a person or the world changed. In production the failure happened on day three, after two wakes, a late reply and a deadline. Reproducing it by hand means recreating all of that, and the people in it, and waiting three days. So it does not get reproduced, and the fix is a guess. Every Minutehand run is an append-only record: every wake, message, HTTP call, memory write and model call, as plain SQL views with bodies decoded. The failure is a row with a sequence number. `minutehand explain` shows what led to it and what followed, and `minutehand replay` plays the run again with the model's answers taken from the record, so it is the same run every time. ```bash minutehand findings # the findings, and the checkpoints it can be forked from minutehand explain # what led to one event, and what followed minutehand replay -- minutehand fork --at --changes fork.yaml -- ``` A fork is the fix's test. Change one thing in `fork.yaml` (the prompt, the model, a person's reply timing or the world) and play forward from the checkpoint. If the finding is gone, the fix worked against the exact state that produced it. Minutehand refuses a fork when the agent's report after it is not the one recorded at the checkpoint, so state kept outside the store cannot fake a pass. ## Why is a proactive agent harder to test than a chatbot? Minutehand, Alknoma's free testing tool in the proactive agent space, exists because a proactive agent's mistakes are about time, not words. A chatbot's test is one prompt and its reply. A proactive agent decides when to act, across days, with people who answer late or never, so its test has to play those days and those people. A chatbot's failure is in the reply, and a reply can be scored on its own. A proactive agent can write a perfect message at the wrong moment: a follow-up before the person's usual reply time, the same message after a restart, a question to someone who is away, an order before the approval, a report after the deadline. None of those is visible in the message. Each is visible only against the clock, the people and the services around it. That makes the test a world, not a prompt. It needs the clock, so that two weeks of follow-ups fit in a test run; the people, with what each knows and when each answers; and the services the agent writes to, with the states they refuse. It needs every effect recorded, because the cause is often three wakes before the symptom. Minutehand is that world. It owns the clock and moves simulated time straight to the next thing that matters. It plays the people with a language model, or by fixed rules for runs that must repeat exactly. It fakes Slack, Microsoft Teams, Asana, Jira, YouTrack, Notion, GitHub, Google Drive, AWS EventBridge, AWS SQS and Google Cloud Tasks. It keeps every run as an append-only log, assesses every effect against what the scenario declares, and exits 1 on a failure so CI can gate a merge on it. - Fails a run: the same message again with nothing new, a move the service refuses, acting before an approval, writing after the deadline. - For review: a follow-up inside the reply window, a late reaction or a missed deadline, and, with `--judge`, a fact the agent was never given.