One runtime between your agents and the tools they call. Connect in five minutes, then every action is scoped, checkpointed, exactly-once and signed — without touching your agent logic.
Invoke runs under the frameworks you build on and stands in front of the tools they call. Nothing below is a customer logo — it is the surface area we govern.
A runtime that sits between your agents and the tools they call. Identity, policy, approvals, exactly-once execution and a signed ledger — in one hop, behind the same tool interface your agent already uses.
The agent holds the API key and calls the tool directly.
Callbacks and interrupts inside LangGraph, CrewAI or your own loop.
Out of process, in front of the tool, under every framework.
No dashboards to trust and no screenshots to believe. Each execution leaves a signed record that survives the process that made it — verifiable from the CLI, replayable from the ledger.
One append-only record of every call across every agent. The colour of a cell is its outcome — the same four hues the hero is built from, at the scale you actually read them.
Not a measured rate — a property. A retry cannot produce a second effect, because the runtime owns the idempotency key and reconciles before it re-fires.
A call without a caller, an intent and a scope does not get made. There is no path through the runtime that skips the record.
npm i -g @invokehq/cli, point your tools at the gateway, keep your agent code. Nothing about the loop changes.
The things every team eventually builds badly — dedupe, scoping, approvals, an audit trail — arrive as runtime behaviour on the first call, not as a quarter of platform work.
Retries after ambiguous failures reconcile against ground truth before they re-fire. One intent, one effect — the duplicate charge stops being possible rather than becoming unlikely.
Policy lives in the runtime, not in the loop. An agent that gets talked into calling refunds still finds nothing on the other side, because the decision was never the model’s to make.
LangChain, LangGraph, CrewAI, the OpenAI and Claude SDKs, or a loop you wrote yourself. Invoke sits underneath, so a second framework doesn’t mean a second set of guardrails.
Identity, context, coordination, execution and observability are one system on purpose — an approval is worth nothing if the identity it was granted to is a guess.
Persistent agents with a version, a scope and a history. Every call carries who ran it and under which policy — the record travels with the effect, not beside it.
Human-in-the-loop exactly where it matters. The risky call pauses with full intent attached and resumes on approval — bound to that execution, so it can't be replayed later.
Every effect lands in one append-only ledger. Replay an execution from any point, diff two runs, and verify a receipt offline — the console is a fold over the same events.
Not a roadmap. These are the behaviours the runtime enforces the moment your tools point at it.
Invoke sits on the path of consequential actions, so the posture is stated plainly — including what we do not yet hold. The full document lives on the security page.
Credentials stay in the runtime, never in the agent. Policy is evaluated per agent and per tool, and an out-of-scope call is refused before it reaches your provider.
Receipts are signed on completion and verifiable offline. GDPR supported, DPA available on request, sub-processors published. HIPAA and FedRAMP are not offered.