Connect your AI agent
to TrustLoop

https://trustloop.live/openapi.json

Before taking any sensitive action — sending emails, accessing
databases, calling external APIs, transferring data, or modifying
files — call the TrustLoop interceptToolCall action first.

Pass the action name as tool_name, all relevant parameters as
arguments, and set agent_name to this GPT's name.

Rules:
- allowed: true → proceed.
- allowed: false, status BLOCKED → do NOT proceed.
  Tell the user: "This action was blocked by your organisation's
  AI governance policy: [message]"
- allowed: false, status PENDING → do NOT proceed.
  Tell the user: "This action requires human approval. Your
  administrator has been notified."

https://api.trustloop.live/sse?api_key=tl_your_key_here

{
  "mcpServers": {
    "trustloop": {
      "url": "https://api.trustloop.live/sse?api_key=tl_your_key_here"
    }
  }
}

from trustloop import TrustLoop

# Get your MCP URL programmatically
url = TrustLoop.mcp_url("tl_your_key_here")
# → "https://api.trustloop.live/sse?api_key=tl_your_key_here"

pip install trustloop-sdk[langchain]

from trustloop import TrustLoop
from trustloop.integrations.langchain import wrap_tools

tl = TrustLoop(
    api_key="tl_your_key_here",
    agent_name="my-langchain-agent"
)

# Your existing tools — unchanged
raw_tools = [search_tool, email_tool, db_tool]

# Wrap them — TrustLoop intercepts every call
tools = wrap_tools(raw_tools, tl)

# Pass to your agent as normal
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

from trustloop import TrustLoopBlockedError

try:
    result = executor.invoke({"input": user_message})
except TrustLoopBlockedError as e:
    print(f"Blocked by governance: {e}")

pip install trustloop-sdk[crewai]

from trustloop import TrustLoop
from trustloop.integrations.crewai import governed_tool
from crewai.tools import BaseTool

tl = TrustLoop(api_key="tl_your_key_here", agent_name="my-crew")

@governed_tool(tl)
class SendEmailTool(BaseTool):
    name: str = "send_email"
    description: str = "Send an email"

    def _run(self, to: str, subject: str, body: str) -> str:
        # Only runs if TrustLoop allows it
        ...

pip install trustloop-sdk openai

from trustloop import TrustLoop
from openai import OpenAI

tl = TrustLoop(api_key="tl_your_key_here", agent_name="my-openai-agent")
client = OpenAI()

# In your tool dispatch loop:
for tool_call in response.choices[0].message.tool_calls:
    fn_name = tool_call.function.name
    fn_args = json.loads(tool_call.function.arguments)

    # Intercept BEFORE executing
    result = tl.intercept(fn_name, fn_args)
    if not result["allowed"]:
        tool_result = f"Action blocked: {result.get('message')}"
    else:
        tool_result = run_tool(fn_name, fn_args)

pip install trustloop-sdk

from trustloop import TrustLoop

tl = TrustLoop(api_key="tl_your_key_here", agent_name="my-agent")

@tl.guard("send_email")
def send_email(to: str, subject: str, body: str):
    # Only runs if TrustLoop allows it
    ...

@tl.guard()  # uses function name as tool name
def delete_records(table: str, where: dict):
    ...

result = tl.intercept("transfer_funds", {
    "amount": 50000,
    "to": "GB29NWBK..."
})

if result["allowed"]:
    run_transfer()
else:
    print(f"Blocked: {result['message']}")

npm install trustloop

import TrustLoop from 'trustloop';

const tl = new TrustLoop({
  apiKey: 'tl_your_key_here',
  // or: process.env.TRUSTLOOP_API_KEY
});

// Before any sensitive tool call:
const result = await tl.intercept('send_email', {
  to: 'ceo@bank.com',
  subject: 'Contract'
});

if (!result.allowed) {
  throw new Error(result.message);
}

// Safe to proceed
await sendEmail(...)

import OpenAI from 'openai';
import TrustLoop from 'trustloop';

const openai = new OpenAI(
  TrustLoop.openai('sk-your-openai-key', 'tl_your_key_here')
);
// All tool calls are now governed automatically

Method:  POST
URL:     https://api.trustloop.live/api/intercept
Headers:
  x-api-key:     tl_your_key_here
  Content-Type:  application/json
Body:
  {
    "tool_name":  "send_email",
    "arguments": { "to": "{{email}}", "subject": "{{subject}}" },
    "agent_name": "my-workflow"
  }