The live control room for your AI agents
See everything, set rules, stop anything. Jeprum sits between your agent and its tools — enforcing guardrails before a call executes, streaming every event to a live dashboard, and giving you a remote kill switch.
Your agent just decided to call delete_file. What happens next?
Observability tools tell you what your agent did — after it did it. Jeprum decides what your agent is allowed to do, at the moment it tries.
- 1LLM decides to call the tool
- 2The tool executes. The file is gone, the email is sent, the card is charged.
- 3You find out later, in a trace.
- 1LLM decides to call the tool
- 2Jeprum evaluates your rules synchronously, before execution — a blocked call never runs.
- 3The agent receives structured feedback and adapts. You watch it live, and can kill it from anywhere.
One interception point. Total control.
Wrap your MCP session
jp.monitor(session) returns a drop-in replacement with the same interface. Swap one object — the rest of your agent loop stays untouched.
Rules run before every call
Blocked tools, daily spend caps, rate limits, and alert patterns are evaluated synchronously. Violations raise typed exceptions your loop feeds back to the LLM as tool results.
Control from the dashboard
Live event timeline, per-agent cost tracking, kill / pause / resume. Rules created in the dashboard sync to running agents in seconds — no restart.
Everything you need to run agents you don’t fully trust yet
Guardrails before execution
Block tools by glob pattern (delete_*, send_*). Rules are checked between the LLM's decision and the tool's execution — a blocked call never runs.
Remote kill switch
Kill, pause, or resume any agent from the dashboard. Running agents pick up the status on their next tool call — from anywhere, no SSH required.
Spend caps & rate limits
Cap cumulative daily spend per agent, rate-limit calls with sliding windows, and flag sensitive patterns with alert-only rules that never block.
Live rules sync
Create or toggle a rule in the dashboard and it applies to running agents within seconds. No restart, no redeploy, no config push.
MCP-native, zero rewrites
Wraps the standard MCP ClientSession with the same interface. Works with any model and any framework that speaks Model Context Protocol.
Telemetry that never blocks
Every call becomes a structured event — local JSONL, cloud, or both. Shipping is asynchronous and fire-and-forget: a telemetry failure never crashes your agent.
Five lines. Any MCP agent.
Wrap your session, declare your rules, and keep calling tools exactly the way you already do.
from jeprum import Jeprumjp = Jeprum(api_key="jp_live_...", transport_mode="cloud")monitored = jp.monitor(session, agent_name="research-assistant", rules={"blocked_tools": ["delete_*", "send_email"],"max_spend_per_day": 10.0,"rate_limit": {"max_events": 100, "period_seconds": 60},})# same interface as your MCP session — nothing else changesresult = await monitored.call_tool("web_search", {"query": "..."})
# the blocked call never executes;# your loop feeds the reason back to the LLMexcept GuardrailViolation as e:tool_result = f"BLOCKED: {e.reason}"
Exceptions as control flow
Guardrail violations surface as typed exceptions — GuardrailViolation, AgentKilled, AgentPaused. Fed back as tool results, models adapt gracefully instead of crashing.
Ship agents you can stop
Open source, Apache 2.0, MCP-native. Install the SDK, wrap your session, and watch your agents in the control room.