Register an agent in your workspace and keep its scoped credential on the agent host. Then choose how it reports: the Python or Node.js SDK, the HTTP contract from any language, the OpenTelemetry traces your framework already emits, or Toolcaise Connect on the machine that runs it. Every path is outbound HTTPS, and your model-provider keys stay with your agent.
One revocable credential per agent, shown once when it is created.
Confirm the first heartbeat, then instrument the actual work: a heartbeat alone is not monitoring.
Toolcaise does not discover agents on its own. Each path needs a short setup step.
Wrap work in a run and add spans around steps, tools, models and retries. The dashboard shows the reported sequence, timing, failures, token usage and costs when they are supplied. Your agents keep running on their own hosts.
Run and event IDs stay stable across retries, so a retried report is not counted twice.
Figures an agent reports are its own claim. Cost from the SDKs may be partial or overlap across spans.
The SDKs never capture raw prompts, outputs or exception text on their own.
Toolcaise opens an incident for a stale heartbeat, an overdue schedule, a stalled run or repeated failures, and can notify the destinations your workspace sets up: a Slack channel, an HTTPS webhook signed with HMAC-SHA256, or email. Acknowledge an incident to record attention; close it to record your response. An active condition stays visibly separate from a closed incident.
Heartbeat: 10 minutes without a report, or the check-in set for the agent. Schedule: 15 minutes overdue.
Stalled run: 30 minutes without an update. Repeated failure: three consecutive failed attempts.
The server checks every workspace about once a minute, and the dashboard says when checks are delayed.
A finished process does not establish a useful result. Agents can report an outcome with a label, a status and an optional artifact digest. Workspace owners and admins accept or reject it, and every review is kept.
An agent’s report is a claim, not independent evidence of delivery.
A human review records a decision; inspect the actual artifact before accepting it.
Keep private outputs out of labels and free-text event messages.
Through the SDKs, pause, resume and cancel are cooperative: your runner checks for them at checkpoints you place. The dashboard shows whether a command was requested, delivered and acknowledged. Guarded actions wait for a person to approve the exact action, bound by a digest, and consume that approval once.
Place checkpoints between safe steps; they cannot interrupt a call already in flight.
Put every execution parameter in the guarded action and execute the approved snapshot.
Network uncertainty fails closed for guarded actions. Code that never reaches a checkpoint is not stopped: for a hard stop, use a Connect supervised run.
Wrap a command in toolcaise-connect run and Connect puts a local gateway on its model traffic. It measures each call from the provider’s own usage figures and stops the command, with every process it started, at a runtime, cost, token or model-call limit. With --remote-control, the dashboard can pause, resume and stop that run and set per-agent limits; the stricter of the dashboard’s and the machine’s value always wins.
Metering covers OpenAI- and Anthropic-compatible APIs reached through OPENAI_BASE_URL, OPENAI_API_BASE or ANTHROPIC_BASE_URL. An agent that hard-codes an endpoint bypasses it; the runtime limit and the stop still apply.
Cost is computed only from prices you supply. With a cost limit set, a model without a price is refused.
toolcaise-connect mcp gates MCP tool calls by name and budgets them per session. It does not inspect arguments; with --remote-control it can hold a call for a person's approval in the dashboard.
Connect is a preview: its builds are not yet code-signed.
Seeing an agent and being able to stop it are different things. This is what each way of connecting can do.
Integration paths and what each one can enforce
Path
What Toolcaise sees
What it can enforce
Python and Node.js SDKs, HTTP
What the agent reports: runs, steps, usage, outcomes
Pause, resume, cancel and exact-action approvals, at checkpoints your code implements. Cooperative: code that skips the checkpoint is not stopped.
OpenTelemetry
Runs, model and tool spans, and token counts from your framework’s own tracing
Nothing. It observes only.
Connect: Claude Code and Codex adapters
The allow-listed events and metrics those tools emit
Nothing. It reports telemetry only.
Connect: supervised run
Every model call made through an OpenAI- or Anthropic-compatible API, measured on your machine, plus the process’s start, end and resources
Runtime, cost, token and model-call limits and a model allowlist, by stopping the whole process tree. Pause, resume, stop and limits from the dashboard.
Connect: MCP tool gateway
Every tool call that passes through the proxy
Allow or deny by tool name, a call budget per session, and a hold until a person approves the exact call (Connect 0.3 or later). The approver sees the tool name; the arguments stay on your machine.
Connect your first agent
Create a free workspace, connect the agent you already run, and watch its next run arrive. Free covers 3 agents, with no card required.