Tools for assistants (MCP)

MCP (Model Context Protocol) is how an assistant such as Claude, Cursor or your own agent works with InOrbit: it asks which tools your sign-in or token may use, then calls them by name. MCP shows how to connect one and which scopes open which tools.

Find a toolCopy Anchor Link

There are 277 tools, one page per product, in the same sections as the API reference. A tool's name is the product, then the action: decisions_save_document saves a document in Decisions, coordinator_list_jobs lists the coordinator's jobs. Search the docs for a name, or open a product below. Each tool shows what it does, the scopes it needs, its arguments and a call to copy; put your own ids in place of the example ones.

Three more tools come from the model service and are listed only once an assistant connects: platform_status, list_models and radar_latest.

Accounts and accessCopy Anchor Link

• Account settings: 29 tools. Who is calling and the account they act for: the caller a token stands for, what the account's plan lets it use, its dashboard layouts and monitors board, the Ask Io widget's branding, and the audit log of who changed what.
• Support: 3 tools. Your support requests and whether a support session is open on your account.
• Usage and units: 7 tools. What the account used and what it costs: units by day and by category, the price of each kind of call, the limits that apply to your keys over the last hours and days, and each request the account made with its traffic.
• Domains: 2 tools. Domains the account has proved it controls.

ObserveCopy Anchor Link

• Sensors: 3 tools. Signals from agents, devices and scripts, and from the platform itself.
• Monitors: 5 tools. Scheduled checks on a connection: each monitor's runs, health, uptime and latency over time, and how long their data is kept.
• Incidents: 14 tools. What happened, when, how bad and for how long: each incident with its postmortem and every saved version, a live stream while it is open, the account's incident settings, and a summary of a window of time built from the platform's records.
• Status pages: 8 tools. Public status pages for an account's customers: drafts and saved versions from the designer, publishing, a preview before you publish, and the incident and maintenance notices readers see.
• Trails: 2 tools. Recordings of how people moved through a site, made with their consent: pages, clicks, timings and errors, never what anyone typed.

Events and webhooksCopy Anchor Link

• Webhooks: 3 tools. Endpoints that receive the account's events, signed with a secret you can rotate.
• Events: 2 tools. The catalogue of every event the account can receive, a live stream of them as they happen, counts per day, and the account's notifications.
• Test inboxes: 1 tool. Addresses that keep what is posted to them for a day, to try webhooks without a server of your own.

Agents and automationCopy Anchor Link

• Agents: 4 tools. The agents your account runs in its own networks: enrol one, list and read them, run a check on one, and revoke or delete it.
• Models and sandbox: 6 tools. Ask the platform's models for an answer or an embedding, see which models are up and the tokens left today, and which languages the code sandbox runs.
• Approvals: 7 tools. What waits on a person's yes: agents ask with a frozen payload, a person decides on a signed device, and the work that follows reports progress on the same record.
• Schedules: 9 tools. Who covers approvals, and when: layers of working hours and rotations, overrides above them, and who may act on a kind of request at any moment.
• Guardrails: 3 tools. The policies an agent is checked against before it acts, and the attestations that prove a decision still holds.
• Agent work: 45 tools. Where agents' work is organised: threads you talk to them in, jobs that move through stages with checks, plans and their items, steps and pipelines, messages between agents, shared terminals, and the runners that do the work on your own subscription.

KnowledgeCopy Anchor Link

• Decisions: 46 tools. Spaces of decision documents: requests for comments, studies, product requirements and decision records.
• Memories: 5 tools. What agents and people decided, kept and left open.
• Corrections: 4 tools. What an AI agent learned from being corrected.

InfrastructureCopy Anchor Link

• Hosts and clusters: 12 tools. The account's hosts, clusters and stacks, and runs against them on the account's own agent: an Ansible check or an OpenTofu plan, read-only, with live output and a diff that an apply is pinned to.
• EVM lab: 5 tools. The EVM lab's networks and assignments, read-only chain calls and simulated transactions.
• DNS: 3 tools. The account's DNS, through its own Cloudflare connection: list zones and their records, plan a change, then apply exactly the plan you read.

Integrations and mediaCopy Anchor Link

• Connections: 9 tools. Outside systems the account connects to: the catalogue of connectors they are made from, signing in to a provider, testing a connection, the grants that let a token or a product use one, and each connection's history.
• Extensions: 4 tools. The catalogue of what iohr ext install runs: InOrbit's own listings, your account's private ones and public ones, their versions, the scopes and privileges each declares, and the publishers behind them.
• Voice: 3 tools. Real-time calls with Io, the InOrbit assistant: start one on a thread, read how it went, and hang up.
• Radar: 3 tools. The weekly digests of what changed in Go, Rust and Solidity: the published digests, newest week first, and the items Radar read to write them.
• Schemas: 5 tools. The JSON Schemas InOrbit publishes and keeps: the catalogue, each schema's versions and their differences, and the findings of the schemas check.

EnterpriseCopy Anchor Link

• Cases: 24 tools. Studies of a client and the cases cut from them: versions, shares to a customer organisation or to named people, who opened what, and lessons a person approves before they are kept.
• Impact: 1 tool. The counts behind the Impact page, per account and per assistant client: agents report snapshots, and every surface reads and watches the same picture.