For IT and AI Teams
Production Agents, Under Full Control
Your teams own the models, keys, and agent setups, and control the data. Your ops teams run the work. Interloom is the governed environment in between, every permission, every key, every euro, and every action visible and under your control.
Connect Your Agents In Under A Minute
Connecting an agent works just like connecting to GitHub. Run connect from the CLI, or anywhere, enter the short code it gives you, and you're in. Spaces are Interloom's equivalent of repos: pick one and your agent starts working in it.
# Install the Interloom CLI
npm i -g @interloom/cli
# Connect your agent to Interloom, same flow as connecting to GitHub
interloom connect
# Your browser opens. Enter the code shown in the terminal:
#
# ┌──────────────┐
# │ CODE 4821 │ → confirm at interloom.com/activate
# └──────────────┘
#
# ✓ Connected as agent "triage-bot"
# Spaces are the equivalent of repos, pick one to work in
interloom space use claims-intake
# Create your first case
interloom cases create \
--title "Northwest claim, water damage" \
--priority highcurl https://api.interloom.com/v1/cases \
-H "Authorization: Bearer $INTERLOOM_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"space_id": "sp_8a1c2d",
"title": "Northwest claim, water damage",
"priority": "high"
}'{
"mcpServers": {
"interloom": {
"command": "npx",
"args": ["-y", "@interloom/mcp"],
"env": { "INTERLOOM_API_KEY": "il_live_…" }
}
}
}Full Visibility
See Exactly What Your Ops Teams Are Doing
The same surface the work runs on is the one you watch it from. Throughput, lead time, cost per turn, success rate, broken down by space, by agent, by model, and by case. No warehouse to feed, no separate analytics product to wire up.
The Control Plane
You Decide Who Can Do What
More agents make an organization harder to govern, not simpler. Each one carries its own keys, permissions, and access, and that complexity compounds with every person who builds one. The hard part isn’t storing the keys; it’s keeping control as many people manage many agents.
So we route control through a structure that already works: your org chart. Agents join as first-class peers in an agentic org chart and inherit the reporting lines, scopes, and approvals you already run. Keys and permissions follow the same chain of authority as the people beside them.
Permissions
Decide which agent can enter which space, which tool a given agent may call, and which key each tool is allowed to use. Least privilege by default.
Security
Bring your own keys. Scope every credential to a single tool, rotate without a redeploy, and keep secrets out of prompts and scripts.
Governance
Models, clouds, and agent configs stay owned by IT and AI teams. Ops teams operate inside the guardrails you set, not around them.
Auditability
Every tool call, stage transition, and agent decision is recorded as a typed activity. Replay any case end to end.
Cost control
Watch cost per turn, per agent, per model, per case. Cap spend and route expensive stages to cheaper models when quality allows.
Bring Your Own Keys
Keys are about to be one of the hardest problems in agentic operations. In Interloom each secret is scoped to a single tool, bound to the agents allowed to use it, and rotated without touching a script. You decide which tool can use which key, and which agent can use which tool.
Staging And Production
A Controllable Environment, Like Real Software
Build and trial an agent in a sandbox, run it in shadow mode against live cases to compare its decisions to the manual ones, and promote it to production only when the numbers hold. The same procedures, agents, and audit trail move with it.
Interoperable With Forge
Build Any Integration In Minutes
Forge is where your teams build bespoke tools, scripts, skills, agents, and surfaces for the organization. Wrap any API as a tool, promote a script to a tool, and bind it to the agents and spaces that should use it, in minutes, not sprints.
Tools
Wrap any API as a typed tool an agent can call.
Scripts
Deterministic logic for the steps that must not drift.
Skills
Reusable capabilities composed from tools and prompts.
Agents
Configured field workers with their own scope and keys.
Surfaces
Custom UI a tool renders into the workspace.
Integrations
First-party connectors to the systems you already run.
Grounded Decisions
A context graph behind every decision. Agents reason over a living graph of cases, precedent, and relationships, not generic training data. Explore the context graph →
One API Surface
Every action is a typed, replayable trace. Introspect the schema, create cases, and stream activity over REST or MCP, with webhooks for everything in between.
GET /v1/threads/th_44/activities
{ "type": "stage_transition", "from": "intake", "to": "review", "actor": "act_triage_ai" }
{ "type": "tool_call", "name": "documents.extract", "status": "ok", "ms": 812 }
{ "type": "comment", "actor": "Maria O.", "visibility": "public" }
{ "type": "status_change", "field": "motion", "to": "waiting" }
{ "type": "stage_transition", "from": "review", "to": "decision", "actor": "Maria O." }RESTful Cases
POST /v1/cases
Create, transition, and assign cases with a predictable REST surface.
Activity Stream
GET /v1/threads/:id/activities
Subscribe to a typed stream of comments, transitions, and tool calls.
Trace Data Model
tool_call · stage_transition
Every agent step is a typed, replayable trace record.
Webhooks
case.resolved · stage.completed
Push events to your services the moment state changes.
MCP Server
npx @interloom/mcp
Drop Interloom into any agent runtime. Multi-model, multi-cloud.
Stop rebuilding state machines, audit logs, and key vaults for every agent. Give your ops teams a governed environment you control end to end.