_{Agent Sessions, new in 6.0. Run Claude Code, Codex, Copilot CLI or OpenCode inside the app and watch every tool call get checked as it happens. Guide}

Start here

Pick the one that describes you.

I use Claude Code, Codex, Copilot CLI or OpenCode

No code changes. Install the app, then install the plugin for your agent.

pip install "securevector-ai-monitor[app]" && securevector-app
npx @securevector/cli                              # or from npm (needs Python 3.10+)

In the app, click Connect Agents, pick your agent, click Install Plugin, then restart the agent (in Claude Code, run /reload-plugins). From then on every tool call it makes is checked and logged. To run sessions inside the app, click Agents, then + Launch (full terminal on macOS and Linux; output only on Windows for now), or from a terminal:

sv-monitor session launch claude-code ~/project    # comes with the app; npm: securevector monitor session ...

More in the Agent Sessions guide.

I build agents in Python

LangGraph, LangChain or CrewAI: use the SDK for your framework (it brings the app with it). It checks every tool call before it runs.

# pip install securevector-sdk-langgraph
from langchain.agents import create_agent
from securevector_sdk_langgraph import secure_middleware, cost_tracking_middleware

agent = create_agent(model, tools, middleware=[
    secure_middleware(mode="enforce"),   # checks every tool call before it runs
    cost_tracking_middleware(),          # records model tokens and cost
])

Same idea for LangChain and CrewAI; create_react_agent and raw StateGraph patterns are in the LangGraph SDK guide. The framework SDKs record model cost themselves, so do not add instrument() below as well (why).

Plain OpenAI or Anthropic code: the app package includes a tracer and a tool guard. Guide

from openai import OpenAI            # or: from anthropic import Anthropic
from securevector import guard, instrument

instrument()                         # records every OpenAI and Anthropic call: tokens, cost, verdict
client = OpenAI()

@guard(tool_id="orders.lookup")      # checks this tool's input and output
def lookup_order(order_id): ...

with guard.session("ticket-8812"):   # groups one run on the Observability page
    ...                              # your agent loop: model calls and tool calls

I build agents in JavaScript or TypeScript

Run the app from npm. Needs Node 20+ and Python 3.10+ on your PATH; the launcher sets up the rest on first run. No Python? Use a binary installer instead.

npx @securevector/cli

That is all Claude Code, Codex and the other coding agents need; install their plugin as in the first path.

Optional: check the tools in agents you write yourself.

npm install @securevector/sdk

import { guard } from '@securevector/sdk';

const lookupOrder = guard(async ({ orderId }) => fetchOrder(orderId), { toolId: 'orders.lookup' });

Wrap each tool's function with guard() (with the Vercel AI SDK, the tool's execute), whichever framework you use: LangChain.js, the Vercel AI SDK, Mastra or plain Node. API and examples in the SDK repository.

Whichever path you took, open http://localhost:8741: every model call and tool call is there, allowed or blocked, with its cost and trace.

I'm evaluating it for my team

• Where it runs and what leaves it: on each developer's machine, bound to 127.0.0.1, no telemetry. Outbound traffic only for the one-time Guardian model download, SIEM destinations you configure, and Cloud Connect if someone turns it on.
• What the record shows: every tool call in a SHA-256 hash-chained log with a per-rule evidence ledger for blocked actions. The local hash chain shows tampering on this machine; the SIEM Forwarder gives you an off-host copy, and Device Identity ties events to a machine.
• Who controls enforcement: locally, the developer, and every connector fails open, so an agent keeps working unchecked while the app is stopped. Central, read-only policies come from Cloud Sync.
• Licence: Apache 2.0. Read the code, run it air-gapped, or self-host the engine. Full notes, including retention and what the app can see: Evaluating it for a team.

What you get

• Run it here. Launch Claude Code, Codex, Copilot CLI or OpenCode from inside SecureVector and watch the terminal live, with every call and its verdict beside it. Sessions you started in your own terminal can be adopted onto the same board.
• See it. One trace per agent session. Pick an agent on the left, read its whole run as a waterfall on the right. Live follow, replay, and a costliest-turn mark on every run.
• Stop it. Allow, block or log-only per tool, enforced by default. A blocked call is refused straight away and becomes a request you can approve for fifteen minutes or an hour, after which the agent can retry. Blocking on detected threats in prompts and responses is opt-in.
• Catch it. 108 rules covering the OWASP LLM Top 10, MITRE ATT&CK-mapped patterns and agent-attack chains, plus an optional offline ML model, applied while the agent is still running.
• Know where it went. Every external host an agent reached, when it was first seen, and a policy that decides which ones it may reach.
• Keep the record. Every tool call in a SHA-256 hash-chained log; the local chain shows tampering on this machine. Blocked actions get a per-rule evidence ledger.
• Pay less. A local scan of your own transcripts shows why sessions cost what they did, with copyable fixes.
• Keep it. Apache 2.0. No signup. Nothing leaves your machine unless you connect it.

Works with

If ports 8741 or 8742 are taken, pass --port. Prefer an installer? Windows, macOS and Linux builds need no Python.

What's new in 6.0

• Agent Sessions: launch Claude Code, Codex, GitHub Copilot CLI or OpenCode from inside SecureVector and watch every tool call get checked beside the terminal. Guide
• Bring your own sessions: an agent you started in your own terminal appears in the app as soon as it makes a tool call. Add it to the board, continue it in the app, or leave it where it is.
• Unchecked, not just quiet: an agent that is still running but no longer reporting tool calls is marked unverified, so it never looks the same as an idle one.
• Session commands in the CLI: sv-monitor session list | harnesses | unlinked | launch | link | stop (securevector monitor session ... with npm), each with --json.
• Live governance beside every session: tool calls with verdicts, blocks, hosts reached and an approval inbox in a column on the right. Approve a held call for 15 minutes, 1 hour or the rest of the session without leaving it.
• Session board and summary: sessions grouped by folder with cost, calls and blocked counts; a summary when a session ends (duration, tool calls by verdict, hosts, findings), exportable as JSON.
• Observability (was Traces): each run shows a step list with model time vs tool time, and Agent Health points out loops, failing steps, waste and blocked runs. CSV and PDF exports include the steps.
• Governance coverage: see how many of your agents' tool calls SecureVector recorded and checked, and a list of gaps to close.
• Live Runs in the cloud (Cloud Connect): every governed session on your devices, live, with its title and folder name and the same step timeline. Metadata only.
• Antigravity plugin: install it from Connect Agents like the others.
• Install from npm: npx @securevector/cli runs the same app for Node developers, and @securevector/sdk checks tools in JavaScript and TypeScript agents.

Full release history in the CHANGELOG.

Screenshots

Agent Sessions board: sessions grouped by folder, with calls, blocked count and age on each card.	Observability: a step list per run with model time versus tool time, each call's verdict, and Agent Health findings.
Agent Map: harnesses, sessions and tools, with blocked calls in red.	Tool Activity: every tool call in a SHA-256 hash-chained log, each row integrity-verified.

More screenshots: Agent Map, Dashboard, Cost / Token Optimizer, Skill Scanner.

Install

Only download installers from this repository. The npm launcher details, SDK-only and MCP extras, and updating are in the Installation guide.

Documentation

• Getting Started: first run, how scanning works, threat modes, AI analysis
• Installation: pip, npm, binary installers, self-host, upgrading
• Configuration: svconfig.yml, MCP Policies Cloud Sync, pointing an agent at the proxy
• Agent Sessions: launch and govern Claude Code, Codex, Copilot CLI and OpenCode in the app
• Features in depth: every feature, performance, notes for teams evaluating it
• Threat detection: what the 108 rules catch, and the Guardian ML layer
• Screenshots: every view of the app
• Python @guard, Claude Code plugin, OpenClaw plugin: connecting each kind of agent
• Tool Permissions: allow / block / log_only per tool
• Tracing: OpenTelemetry and the Observability page
• Device Identity: the per-machine device_id on every row
• Skill Scanner: static analysis of skill packages before you install them
• SIEM Forwarder: destinations, what leaves the machine, starter dashboards
• Use Cases & Examples: LangChain, LangGraph, CrewAI, Hermes, n8n, FastAPI
• MCP Server Guide: Claude Desktop, Cursor integration
• API Reference: REST API endpoints
• Security Policy: vulnerability disclosure and verifying your install
• Changelog

Contributing

git clone https://github.com/Secure-Vector/securevector-ai-threat-monitor.git
cd securevector-ai-threat-monitor
pip install -e ".[dev]"
pytest tests/ -v

Contributing Guidelines · Code of Conduct

Feedback

A wrong detection is the most useful thing you can send. Every detection in the app has a Report this rule link that opens a prefilled false-positive report with the rule id, version and platform, and nothing else. Anything else: open an issue, say hello on Discord, or email contact@securevector.io. If SecureVector is earning its place on your machine, a star helps others find it.

Cloud (optional, opt-in)

A separate cloud product handles MCP tool-permission policy sync across enrolled devices, per-org audit attribution, and per-device fleet slicing. It also adds AI Agent Governance, your agents' governance posture rolled into a single score across the fleet (app.securevector.io/governance), plus EU AI Act orientation that maps your action-layer logging and tamper-evident tool-call audit to the relevant obligations (governance/eu-ai-act); orientation only, not legal advice. Sign in for the fleet-wide view; the local install already gives you the single-device snapshot. Strictly additive: the local install above works standalone without it. Details: securevector.io.

License

Apache License 2.0, see LICENSE.

The starter SIEM dashboard templates under docs/siem/ (Splunk XML, Sentinel workbook, Datadog + Grafana JSON) are MIT-licensed; see docs/siem/LICENSE and docs/siem/NOTICE for trademark disclaimers.

SecureVector is a trademark of SecureVector. See NOTICE.