Requivo

Find what could change the solution before you commit to the scope.

Paste a client or stakeholder request. Requivo identifies the assumptions and missing decisions that could change the workflow, integrations, permissions, timeline or effort — then produces one brief you can review before estimating.

The shared understanding is the source of truth. Every document is generated from it.

Built for Product Managers, Solutions Engineers and Business Analysts working on complex, configurable B2B products.

Start here

1. See a real run — no key, nothing installed

uvx --from requivo requivo demo

Ten seconds, offline — or watch the short demo video instead. A messy client email, the questions Requivo raised against it, the decision brief it wrote, and then the part that is not reasoned at all: change one answer, and it reports what that invalidates, computed from the dependency graph. No Anthropic key, no network, no extras — the demo path needs neither the provider SDK nor a credential.

2. Requivo Web — the way to use it

A local browser workspace. Paste a request, answer the few questions that could change the solution, see what each answer moved, generate one decision brief.

uvx --from "requivo[web,anthropic]" requivo web    # opens http://127.0.0.1:8765

Analysing a request of your own needs a key: set ANTHROPIC_API_KEY in your environment or a .env file. Without one the interface still opens, reads existing sessions and tells you what is missing — and its home page offers Explore a worked example, which materialises the same messy client email requivo demo replays as a real, browsable session in your workspace. One click, no key, no network: the understanding, the open questions, the readiness verdict and the decision brief, all read from the payload bundled with the install. Refining it or generating any other document is the part that needs the key.

What it costs. You pay Anthropic directly, on your own key: roughly $0.03 to $0.06 per call, and $0.46 to $1.01 for a complete session — a full discovery plus every artifact — at current rates. Every command that spends prints its own exact tokens and estimated cost when it finishes. The per-step table, its method and its limits are in docs/providers.md; the figures there are recomputed from the rate table on every build, so they cannot quietly go stale.

One command, nothing installed — uv fetches Requivo into a temporary environment and runs it (curl -LsSf https://astral.sh/uv/install.sh | sh if you don't have uv). To keep it around, uv tool install "requivo[web,anthropic]" and then just requivo web; pipx install works the same way. Prefer plain pip? docs/getting-started.md has the virtualenv route — avoid pip install --user, which succeeds while leaving requivo off your PATH.

Sessions stay on your machine, the server binds to localhost, and nothing leaves your workspace — no accounts, no database, no remote storage. See docs/web.md.

Two other ways in, on the same local sessions — nothing is locked to the interface you start in:

• Claude Code — an integration. /plugin marketplace add jbkkz/requivo, /plugin install requivo@requivo, /reload-plugins, then /requivo:discover <request>. Reasoning goes through your own Claude session, so there is no extra API key — but the skills drive the requivo CLI, so it still has to be installed (above) and on your PATH. If it is not, every skill says so and how to fix it, rather than failing at the shell. On native Windows it also needs Git for Windows, which is what gives Claude Code the Bash tool the skills run through.
• CLI — infrastructure. requivo discover | status | brief …, for automation and anything you drive from a script or a pipeline.

Install and first run in depth: docs/getting-started.md.

Why Requivo

An LLM will happily turn a half-understood request into a polished PRD. Clean documentation is not the same as a correct understanding — and the expensive mistakes come from the question nobody thought to ask, the one that turns a "small feature" into a three-month build.

Requivo asks a question only when the answer would materially change the solution. The rest, it infers and marks as an assumption to confirm. You spend discovery time where it moves the needle.

And because it keeps the understanding rather than just the answer, it can tell you what a changed answer costs:

You change one answer:
  "The migration is one-time. After cutover, the legacy system is read-only."

Requivo:
  What changed        Integrations & notifications
  Needs review        the two-way sync decision · the reconciliation risk · the decision brief

That is the part a chat transcript cannot do.

The canonical example is examples/leave-approval/ — one line of request, taken through the questions, the brief, and a changed answer that moves the scope. A harder, messy multi-feature one lives in examples/event-checkin-reconciliation/, and is what requivo demo replays.

How it works

1. Bring a request — a sentence or a rambling email; a symptom, not a spec.
2. Clarify high-impact unknowns — Requivo asks only what would change the solution, and infers the rest as assumptions to confirm.
3. Build and validate the understanding — a versioned, typed model that is the durable product.
4. Generate traceable documents — each is a view of the model, and knows which decisions it rests on.

The decision rule is information value = uncertainty × impact. Impact is estimated from the product context you give it, so better context means sharper questions.

The main output is a decision brief — the smallest document a scope review can be run from: what is confirmed, what is assumed, the decisions on record, the premises worth contesting, and what is still open. It is not a PRD; it is what you read before writing one. A PRD, user stories, acceptance criteria, an uncertainty-aware estimate, a delivery epic with GitHub/GitLab issue plans and release notes all generate from the same understanding, without redoing the discovery.

The vocabulary — what we know, what we are assuming, open question, needs updating, are we ready — and the model underneath it: docs/requirements-model.md.

Architecture

       Web          Claude Code        CLI / API
   (the product)   (an integration)  (infrastructure)
         \               |                /
                    Requivo Core
            validated, versioned understanding

Every interface uses the same session format and the same validated apply path — there is no fork, and no interface holds business logic of its own. The three differ in weight, not in what they can reach. The Core is provider-independent: no LLM, no network. More: docs/architecture.md.

Building on Requivo as a library? The package ships a PEP 561 marker (py.typed) and declares a small, deliberately stable import surface — the services, the SessionRepository and ReasoningProvider protocols, the boundary contracts, the error vocabulary, requivo.usage — priced like every other promise on the compatibility page. Pin exactly (requivo==X.Y.Z); everything not on that list, including providers.anthropic internals, can move in a minor. Building a non-file SessionRepository (a Postgres backing, most concretely)? pip install 'requivo[testing]' and subclass requivo.testing.repository_conformance.SessionRepositoryConformance in your own pytest suite — the same behavioural proof FileSessionRepository and this repo's in-memory fake both run against, extracted so an external implementation can hold itself to it too.

Data and privacy

Local by default. Sessions live in .requivo/sessions/ in your workspace. No telemetry, no analytics — Requivo never phones home. When a provider is used, each turn sends your request, answers, prompts, schema and loaded context cards to the Anthropic API, and to no other server; in Claude Code mode, reasoning goes through your own Claude session. Treat anything you type as content sent to a model provider. Full notes: SECURITY.md.

Documentation

Everything else — session format, providers, context cards, evaluations, product validation, roadmap, open-source strategy — is indexed in docs/.

Supported platforms

An untested platform and a supported platform look identical from outside, so this table says which is which. The ends of the version range are tested on macOS and Windows rather than every minor version, and the ends are the point: a platform's own standard library can behave differently at each one. Windows on 3.9 cannot resolve a symlink whose target is missing, where Windows on 3.13 can — which once left a path-containment guard holding on twelve of thirteen CI legs and not on the thirteenth. Differences in the language itself show on the Linux axis, which runs all five.

Those legs test the requivo package. Nothing in CI exercises the Claude Code plugin, which runs inside Claude Code rather than inside Python, and on native Windows that plugin carries a prerequisite of its own: Git for Windows, for the reason the plugin README gives.

Requivo reads and writes UTF-8 everywhere, regardless of the machine's locale or the console's codepage. A session written on one machine reads back byte-identically on another. Where a console cannot represent a character Requivo prints, the character is escaped rather than dropped and never crashes the command — requivo doctor reports your console's encoding when there is something worth saying about it. A file you pass in (requivo discover ./brief.md) must be UTF-8; one that is not is refused by name rather than silently decoded into something that reads like prose and is wrong.

Status

Actively developed. The Core, CLI, Claude Code plugin and local Web interface are usable today, and what is stable is stated rather than inferred from the release number: Requivo is versioned with SemVer, and the session format is a published contract — versioned, forward-compatible, and shared by every interface. What is guaranteed and what is deprecated is written down in compatibility. Output is non-deterministic — treat the decision brief as a senior colleague's read, not an oracle, and get expert review for any legal/tax/compliance flag it raises. See the roadmap.

Ran it on a real request? Tell us how it did. No telemetry means this report is how the questions get better — say whether they were useful, useless or redundant, and what a senior PM/BA would have asked that Requivo did not. Anonymise anything client-confidential before posting.

How this is built

Requivo is written by AI coding agents under maintainer direction and review. Most commits carry an agent co-author trailer, and the maintainer decides what gets built, reviews every change and merges it.

The controls around that are the interesting part, and they are not incidental to it. Nothing reaches main except through a squash-merged pull request that passed every required check, on the platform matrix above. The test suite is hermetic — no API calls, no network, no build step — and a large share of it guards the codebase against its own authors rather than against users: a boundary test that fails when the engine imports a provider, an encoding test that walks every file read in the repository, a test that fails when a comment cites a test that does not exist. Each of those exists because a plausible change broke something quietly, and the fix was to make the next such change loud.

That is the honest account of who wrote this. Judge it on the guards and the record, not on the authorship.

Contributing and license

Contributions are welcome — see CONTRIBUTING.md. The Core, CLI and Claude Code integration are open source under Apache-2.0. The Requivo name and identity are separate from the code license — see TRADEMARKS.md.

Apache-2.0 © jbkkz

Requivo was previously named Product Copilot.