Adrian

No entries match these filters. Clear filters

1. docs update Aug 26, 2026 · issue 057

   Adrian open-sources its agentic AI security backend with WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. ingestion, LLMLLMA large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. classifier, and a full configuration surface

   └──▷ TRY IT
   Poll the readiness probe in CI or a health-check script to confirm the database and classifier are both up before routing traffic.
   copy

   $ curl -sf http://localhost:8080/readyz && echo 'stack ready'

   Switch to a smaller GGUFGGUFThe single-file model format used by llama.cpp and Ollama, holding the weights, usually quantized, together with the tokenizer and settings needed to run the model locally. variant and increase the context windowcontext windowThe maximum amount of text, counted in tokens, a model can take in and produce in one request. Everything the model knows about the task has to fit inside it., then restart the stack to apply the change.
   copy

   $ docker compose --profile setup run --rm setup set-model \
     --gguf gemma-4-E2B-it-Q4_K_M.gguf \
     --ctx-size 16384
   docker compose --profile llm up -d

   • Adds ADRIAN_PII_REDACT env var (default true) to toggle SDK-side PIIPIIPersonally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. regex sweep via .env.
   • Adds ADRIAN_SLIDING_WINDOW_SIZE (default 16) and ADRIAN_SLIDING_WINDOW_TTL_SECONDS (default 86400) env vars to control the per-agent ring buffer of classified turns prepended to classifier prompts for cross-step context.
   • Adds ADRIAN_LLM_CTX_SIZE env var (default 8192) to set the llama.cpp context window, trading VRAMVRAMMemory attached to a graphics processor. Models, intermediate calculations and caches must fit here or be moved to slower memory. for more history.
   • Adds ADRIAN_BACKEND_PORT (default 8080) and ADRIAN_DASHBOARD_PORT (default 3000) env vars to control host-side port bindings.
   • Adds /readyz readiness probe returning {"ok": true, "checks": {"db": "ok", "classifier": "ok"}} and 503 with the failing subsystem named while the model is loading or unreachable — distinct from the /healthz liveness probe.

   +6 more show less

   • Adds /healthz liveness endpoint returning ok as soon as the Go process is up.
   • Adds setup bootstrap subcommand to create data/adrian.db, apply migrations, generate an admin password, and download Gemma 4 E4B (~5 GB) into ./models/ in one shot.
   • Adds setup set-model --gguf <name> --ctx-size <n> subcommand to swap the local GGUF and update ADRIAN_LLM_MODEL_PATH in .env without manual editing.
   • Adds setup reset-password [--password <plaintext>] subcommand to regenerate the admin credential and update the SQLite admin row.
   • Exposes a WebSocket ingestion endpoint at ws://localhost:8080/ws accepting protobuf-encoded ClientFrame (login / paired_batch / mcp_inventory) and ServerFrame (login_ack / verdict) frames, authenticated via Authorization: Bearer <api_key> on the upgrade.
   • Ships a Docker Compose stack (--profile llm / --profile setup) combining the Go backend, Next.js dashboard, and a llama.cpp container serving Gemma 4 locally — requires an NVIDIA GPUGPUA graphics processing unit, a processor that performs many calculations in parallel. AI workloads use GPUs to speed up model training and inference. with NVIDIA Container Toolkit and ~10 GB disk.

   11 details in Everything

2. docs update Aug 26, 2026 · issue 057

   Adrian Claude Code plugin adds runtime hook-based enforcement with ALERT/BLOCK/HITLHITLHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. modes, WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. backend, and ~/.adrian/.env config

   └──▷ TRY IT
   First-time setup: install the plugin from the marketplace and run guided configuration to connect to Adrian Cloud.
   copy

   $ /plugin marketplace add secureagentics/Adrian
   /plugin install adrian-cc@adrian
   /reload-plugins
   /adrian-init

   Fail closed on backend outage so no tool call is allowed through when the Adrian backend is unreachable.
   ~/.adrian/.env copy

   ADRIAN_CC_FAIL_OPEN=false
   ADRIAN_API_KEY=adr_live_...
   ADRIAN_WS_URL=wss://adrian.secureagentics.ai/ws
   ADRIAN_CC_VERDICT_TIMEOUT=15

   Check connection health and confirm the correct backend is active after reconfiguration.
   copy

   $ /adrian-status

   • New /plugin marketplace add secureagentics/Adrian and /plugin install adrian-cc@adrian commands install the Adrian runtime security plugin directly from inside Claude Code without any pip install step.
   • New /adrian-init command guides setup: selects backend (Adrian Cloud, self-hosted OSSOSSOpen-source software: code whose licence permits anyone to inspect, modify, and redistribute it. Cyber tools build on it to reuse auditable libraries without licensing fees., or custom URL), writes ~/.adrian/.env, and verifies the WebSocket connection.
   • New /adrian-status command shows the configured backend URL, whether ADRIAN_API_KEY is set, and current connection health.
   • Adds ADRIAN_API_KEY (required, adr_live_... for Adrian Cloud), ADRIAN_WS_URL (default ws://localhost:8080/ws), ADRIAN_CC_VERDICT_TIMEOUT (default 15 seconds), and ADRIAN_CC_FAIL_OPEN (default true) environment variables in ~/.adrian/.env to control backend auth, endpoint, timeout, and fail-open/fail-closed behaviour.
   • Supports three server-driven enforcement modes — ALERT (log only), BLOCK (deny high-risk tool calls before execution), and HITL (Human Review: inline approve/deny prompt) — with no client-side hard-wiring; policy is set on the backend.

   +3 more show less

   • Classifies every Claude Code tool call at PreToolUse via WebSocket/protobuf before the tool runs, and captures tool outputs at PostToolUse, with severity codes M0/M2/M3/M4; default policy acts on M3/M4.
   • Tracks sub-agent activity spawned via the Agent tool with parent/child hierarchy, groups events by triggering user prompt, and extracts Claude's reasoning and instructions from the session transcript.
   • Supports marketplace updates via /plugin marketplace update adrian followed by /plugin update adrian-cc@adrian.

   8 details in Everything

3. docs update Aug 26, 2026 · issue 057

   Adrian TypeScript SDK (@secureagentics/adrian) instruments LLMLLMA large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. calls with PIIPIIPersonally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. redaction, JSONLJSONLA text format where each line is a self-contained, valid JSON object, making it easy to stream, append, and process large datasets line by line without parsing a full JSON array into memory. logging, WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. streaming, and policy verdicts

   └──▷ USE IT
   Instrument an existing OpenAI agent for Adrian Cloud so every LLM call is captured and classified by severity in the dashboard.
   typescript copy

   import OpenAI from "openai";
   import { adrian } from "@secureagentics/adrian-openai";
   
   await adrian.init({
     apiKey: "adr_live_...",
     wsUrl: "wss://adrian.secureagentics.ai/ws"
   });
   const client = adrian.openai(new OpenAI());
   const response = await client.chat.completions.create({
     model: "gpt-4o",
     messages: [{ role: "user", content: "Summarize threat intelligence for Q2" }]
   });
   await adrian.shutdown();

   Point the SDK at Adrian Cloud and set a session ID for grouping events, using environment variables so no code changes are needed.
   copy

   $ ADRIAN_API_KEY=adr_live_... \
   ADRIAN_WS_URL=wss://adrian.secureagentics.ai/ws \
   ADRIAN_SESSION_ID=pentest-run-42 \
   ADRIAN_BLOCK_TIMEOUT=15 \
   node dist/agent.js

   • New @secureagentics/adrian TypeScript SDK attaches to LLM calls to capture activity events, reasoning traces, and stream them to the Adrian backend over WebSocket, with PII redacted in-process before any data leaves.
   • New @secureagentics/adrian-openai provider package wraps the official openai client (Chat Completions, >=4.0.0) via adrian.openai(client) so every call is captured without changing existing call sites.
   • Configures via environment variables: ADRIAN_API_KEY (required), ADRIAN_WS_URL (default ws://localhost:8080/ws; use wss://adrian.secureagentics.ai/ws for Adrian Cloud), ADRIAN_LOG_FILE (default events.jsonl), ADRIAN_SESSION_ID, ADRIAN_BLOCK_TIMEOUT (default 30 seconds), and ADRIAN_REPLAY_BUFFER_FRAMES (default 1000).
   • Supports BLOCK and HITLHITLHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. policy modes: in BLOCK mode, the SDK waits up to blockTimeout seconds for a backend verdict on proposed tool calls before failing open.
   • Provides manual instrumentation via adrian.getHandler() and shared capture helpers at @secureagentics/adrian/capture, pairing LLM/tool start and end events by a shared runId for frameworks without a provider package.

   +1 more show less

   • Captures reasoning traces where the model exposes them, alongside paired LLM call and tool execution events streamed to the backend.

   6 details in Everything

4. docs update Aug 26, 2026 · issue 057

   Adrian Python SDK adds direct Anthropic SDK instrumentation with Alert/Block/Human Review enforcement modes

   └──▷ USE IT
   Instrument an async Anthropic agent to capture and enforce security policy on every messages.create call, grouping two related calls under one invocation.
   python copy

   import asyncio
   import os
   import adrian
   import anthropic
   
   async def main():
       adrian.init(
           api_key="adr_live_...",
           ws_url="wss://adrian.secureagentics.ai/ws"
       )
       client = anthropic.AsyncAnthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
       async with adrian.anthropic_invocation():
           first = await client.messages.create(
               model="claude-opus-5", max_tokens=1024,
               messages=[{"role": "user", "content": "Step 1"}]
           )
           second = await client.messages.create(
               model="claude-opus-5", max_tokens=1024,
               messages=[{"role": "user", "content": "Step 2"}]
           )  # same invocation_id as first
       adrian.shutdown()
   
   asyncio.run(main())

   Defer Anthropic SDK patching to a controlled point in startup rather than letting init() patch automatically.
   python copy

   import adrian
   
   adrian.init(
       api_key="adr_live_...",
       auto_instrument=False
   )
   # ... other initialisation ...
   adrian.patch_anthropic()  # idempotent; safe to call more than once

   • Adds adrian-sdk[anthropic] pip extra to instrument anthropic.Anthropic and anthropic.AsyncAnthropic directly, capturing every messages.create call as a PairedEvent streamed to the Adrian backend.
   • Adds adrian.anthropic_invocation() async context manager and adrian.anthropic_invocation_sync() for synchronous code to group related Anthropic calls under a shared invocation_id.
   • Adds auto_instrument=False parameter to adrian.init() plus an explicit adrian.patch_anthropic() call for manual control over when SDK patching occurs.
   • Introduces three enforcement modes (Alert, Block, Human Review) pushed via the LoginAck frame: Alert passes responses through unchanged; Block gates each tool_use block on a verdict before returning to caller; Human Review waits on a dashboard decision.
   • Under Block and Human Review modes, halted tool calls are rewritten to a text block containing [BLOCKED by security policy] and stop_reason is downgraded from tool_use to end_turn so agentic loops terminate cleanly.

   +3 more show less

   • Gate fails closed: if no LoginAck arrives within 5 seconds all tool calls are blocked; in Block mode a verdict timeout also blocks the tool call.
   • Each instrumented call produces one PairedEvent with pair_type="llm", carrying model, flattened message list (including system prompt), output text, tool_calls, and token usage via LlmPairData; calls made outside an invocation carry invocation_id="no_invocation".
   • Streaming is supported: text deltas pass through untouched and the PairedEvent is emitted when get_final_message() is awaited.

   8 details in Everything

5. docs update Aug 26, 2026 · issue 057

   Adrian SDK launches with auto-instrumentation for LangChain/LangGraph and Anthropic SDK, shipping paired LLMLLMA large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code./tool events to a hosted or self-hosted backend.

   └──▷ USE IT
   Instrument a LangChain agent and stream all LLM/tool events to the Adrian hosted backend, blocking on verdicts up to 10 seconds.
   python copy

   import asyncio
   import adrian
   from langchain_openai import ChatOpenAI
   
   async def main():
       adrian.init(
           api_key="adr_live_...",
           ws_url="wss://adrian.secureagentics.ai/ws",
           block_timeout=10.0,
           on_block=lambda ctx: print(f"BLOCKED: {ctx.mad_code}")
       )
       llm = ChatOpenAI(model="gpt-4o")
       response = await llm.ainvoke("Summarise today's threat intelligence feed.")
       print(response.content)
       adrian.shutdown()
   
   asyncio.run(main())

   Configure the Adrian SDK via environment variables for a self-hosted backend, writing events to a custom JSONLJSONLA text format where each line is a self-contained, valid JSON object, making it easy to stream, append, and process large datasets line by line without parsing a full JSON array into memory. log path.
   .env copy

   ADRIAN_API_KEY=adr_live_...
   ADRIAN_WS_URL=wss://adrian.secureagentics.ai/ws
   ADRIAN_LOG_FILE=/var/log/adrian/events.jsonl
   ADRIAN_BLOCK_TIMEOUT=15.0
   ADRIAN_REPLAY_BUFFER_FRAMES=2000
   ADRIAN_SESSION_ID=prod-agent-42

   Disable auto-instrumentation to attach the Adrian handler manually, giving precise control over which chains are monitored.
   python copy

   import adrian
   from langchain_openai import ChatOpenAI
   
   adrian.init(
       api_key="adr_live_...",
       ws_url="wss://adrian.secureagentics.ai/ws",
       auto_instrument=False
   )
   handler = adrian.get_handler()
   llm = ChatOpenAI(model="gpt-4o", callbacks=[handler])

   • New adrian-sdk Python package (requires Python 3.12+) installs via pip install adrian-sdk and auto-instruments LangChain/LangGraph and the Anthropic SDK at init time.
   • Introduces adrian.init() with parameters api_key, ws_url, log_file, session_id, block_timeout, replay_buffer_frames, auto_instrument, log_level, and handlers, each backed by a corresponding env var (ADRIAN_API_KEY, ADRIAN_WS_URL, ADRIAN_LOG_FILE, ADRIAN_SESSION_ID, ADRIAN_BLOCK_TIMEOUT, ADRIAN_REPLAY_BUFFER_FRAMES).
   • Defaults ws_url to ws://localhost:8080/ws for self-hosted deployments; set ws_url or ADRIAN_WS_URL to wss://adrian.secureagentics.ai/ws for the hosted service.
   • Supports log_file / ADRIAN_LOG_FILE for JSONL event output (default: events.jsonl); override entirely with a custom handlers= list to suppress both the JSONL handler and the WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. client.
   • Emits PairedEvent dataclass records — serialized identically to JSONL and protobuf — carrying event_id, invocation_id, session_id, run_id, parent_run_id, timestamp, pair_type ('llm' or 'tool'), agent, parent, data, and metadata.

   +8 more show less

   • LlmPairData captures model name, full message list, output text, tool_calls, and token usage; ToolPairData captures tool name, tool_call_id, input string, and output string.
   • Provides event-stream callbacks registerable on adrian.init(): on_event, on_verdict, on_audit (NOTIFY-tier / M2 verdicts), on_block (BLOCK-tier / M3/M4 verdicts), on_mcp_server, on_disconnect, and on_reconnect — accepting sync or async callables.
   • Configures block_timeout (default 30.0 s) for MODE_BLOCK; ignored in MODE_ALERT (no wait) and MODE_HITL (waits indefinitely).
   • Provides replay_buffer_frames (default 1000) ring-buffer to resend frames after a transient WebSocket outage.
   • Under LangGraph, agent identity is derived from langgraph_checkpoint_ns, producing stable hierarchical paths such as 'director|team_lead|worker'.
   • Supports langchain-core >= 1.2.19, < 2.0 and anthropic >= 0.40.0; patches messages.create and messages.stream on both sync and async Anthropic clients.
   • Redacts PIIPIIPersonally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. in-process before any data leaves the host environment.
   • Captures MCPMCPModel Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. server names via LangChain's mcp-adapters integration through the on_mcp_server callback.

   13 details in Everything

6. docs update Aug 26, 2026 · issue 057

   Adrian adds SDK integrations for LangChain, Anthropic, OpenAI, and Claude Code, plus Slack and Discord alerting channels.

   • Supports LangChain agent wrapping via the Adrian Python SDK — two lines of code capture activity logs and reasoning traces from an existing LangChain agent.
   • Supports direct Anthropic SDK usage via the Adrian Python SDK — patches the Anthropic client when calling messages.create without a framework.
   • Supports OpenAI client wrapping via the Adrian TypeScript SDK — one line captures every Chat Completions call.
   • Integrates with Claude Code as a plugin (no code required) — hooks every tool call, classifies it, and enforces policy automatically.
   • Sends one-way alerts to Slack and Discord based on configured thresholds, with channel setup and policies managed from the dashboard.

   +1 more show less

   • API key for SDK authentication is generated from the Adrian dashboard.

   6 details in Everything

7. docs update Aug 26, 2026 · issue 057

   Adrian brings runtime oversight, detection, and control to autonomous AI agents via a 2-line Python SDK.

   └──▷ USE IT
   Start monitoring a LangChain or LangGraph agent against Adrian Cloud with zero changes to the agent itself.
   python copy

   import adrian
   adrian.init(
       api_key="adr_live_...",
       ws_url="wss://adrian.secureagentics.ai/ws"
   )
   # Your existing LangChain / LangGraph agent code runs unchanged below this point.

   • Initialise monitoring with adrian.init(api_key=..., ws_url=...) — connects to either a self-hosted backend (ws://localhost:8080/ws default) or Adrian Cloud (wss://adrian.secureagentics.ai/ws) with no agent code changes required.
   • Set ADRIAN_WS_URL environment variable to point the SDK at the hosted or self-hosted backend without modifying code.
   • Supports LangChain and LangGraph agents, and direct Anthropic SDK calls, all captured automatically after adrian.init().
   • Audit mode (notify-only, no intervention) lets teams observe agent behaviour and review detections before enabling blocking controls.
   • Detects malicious, misaligned, or out-of-remit agent actions classified by severity, using world models that reason over a full session rather than pattern-matching classifiers.

   +2 more show less

   • Analyses agent reasoning traces and thought processes — not just tool calls and outputs — to surface why a decision was made and what the agent plans to do next.
   • Provides human-in-the-loophuman-in-the-loopHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. approval flow to pause or block specific agent actions before they execute.

   7 details in Everything

8. docs update Aug 26, 2026 · issue 057
   └──▷ USE IT
   Point a LangChain or Anthropic SDK agent at Adrian Cloud for hosted runtime monitoring with two lines of initialisation.
   python copy

   import adrian
   adrian.init(
       api_key="adr_live_...",
       ws_url="wss://adrian.secureagentics.ai/ws"
   )
   # Your existing LangChain / LangGraph agent runs unchanged — every call is captured.

   Use the ADRIAN_WS_URL environment variable to switch between self-hosted and cloud backends without changing application code.
   copy

   $ export ADRIAN_WS_URL=wss://adrian.secureagentics.ai/ws

   • Adds adrian.init(api_key=..., ws_url=...) Python SDK initialisation that wraps LangChain, LangGraph, and Anthropic SDK agents with zero code changes to the agent itself.
   • Supports ADRIAN_WS_URL environment variable to configure the backend endpoint, defaulting to ws://localhost:8080/ws (self-hosted) or wss://adrian.secureagentics.ai/ws (hosted cloud).
   • Provides Audit mode (notify-only, no intervention) for passive monitoring of agent actions before enabling blocking controls.
   • Detects malicious, misaligned, or out-of-remit agent actions classified by severity, analysing both behaviour and reasoning traces rather than only tool calls and outputs.
   • Enables pause or block controls on specific agent actions, with optional human-in-the-loophuman-in-the-loopHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. approval workflows.

   +1 more show less

   • Offers self-hosted or cloud-hosted backend deployment options for the monitoring service.
9. python-sdk-v1.2.0 Aug 18, 2026 · issue 050

   Adrian Python SDK v1.2.0 adds reasoning capture for LangChain and TypeScript OpenAI SDK integrations.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch python-sdk-v1.2.0 https://github.com/secureagentics/Adrian.git
   # already have the repo? check out this version:
   $ git checkout python-sdk-v1.2.0

   • Adds a reasoning field to the LLMLLMA large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. event payload emitted by on_llm_end in sdk/python/adrian/handler.py, capturing chain-of-thoughtchain-of-thoughtIntermediate reasoning a model writes out before its final answer. Reasoning models generate it automatically and it is often billed as extra output tokens. output from reasoning models via the new _extract_reasoning() helper.
   • Adds reasoning capture to the TypeScript OpenAI SDK integration, collecting delta.reasoning_content from OpenAI-compatible streaming responses into a reasoning string alongside the existing output.
   • Extends reasoning capture to new integrations and additional models across both Python and TypeScript SDKs, with support for multiple block layouts: summary lists (OpenAI Responses / LangChain default), bare reasoning strings (LangChain output_version='v1'), and Anthropic thinking strings.

   3 details in Everything

10. python-sdk-v1.1.0 Aug 11, 2026 · issue 042

    Adrian Python SDK v1.1.0 adds Claude Code plugin with HITLHITLHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. verdicts, PIIPIIPersonally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. filtering, and Anthropic SDK integration

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch python-sdk-v1.1.0 https://github.com/secureagentics/Adrian.git
    # already have the repo? check out this version:
    $ git checkout python-sdk-v1.1.0

    ⤢
    • Adds Claude Code plugin (integrations/claude-code/adrian_cc/agent.py) that connects Claude Code hooks to the Adrian backend via WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output., supporting three server-driven execution modes: MODE_ALERT (fire-and-forget), MODE_BLOCK (wait for verdict, block per policy), and MODE_HITL (wait for human approval on the dashboard).
    • Adds PII filtering for the Claude Code plugin (adrian_cc/pii/_patterns.py), detecting 12 PII categories: EMAIL, PHONE, SSN, CREDIT_CARD, IP_ADDRESS, DATE_OF_BIRTH, IBAN, PASSPORT, STREET_ADDRESS, POSTAL_CODE, DRIVER_LICENSE, and AWS_KEY.
    • Adds Anthropic SDK integration, enabling Adrian instrumentation for agents built with the Anthropic Python SDK.
    • Forwards HITL verdicts from the Adrian backend to Claude Code for native inline approval workflows.
    • Adds severity badges to the Events table and mobile cards based on MAD codes, with latest verdict metadata now included in the event list API response.

    +1 more show less

    • Extracts LangChain/LangGraph instrumentation into langchain_handler.py, consolidating that integration surface.

    6 details in Everything

11. changes since 2026-07-09 Aug 6, 2026 · issue 039

    Adrian gains a Claude Code plugin with HITLHITLHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. verdict forwarding, three execution modes, and PIIPIIPersonally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. filtering for agent conversations.

    • New Claude Code plugin (integrations/claude-code/adrian_cc/agent.py) connects Claude Code hooks directly to the Adrian backend via WebSocketWebSocketA protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output., sending SessionLogin + PairedEvent protobuf messages and returning allow/deny/advisory verdicts.
    • Supports three server-driven execution modes read from PolicySnapshot on LoginAck: MODE_ALERT (fire-and-forget, never blocks), MODE_BLOCK (waits for verdict, blocks per policy), and MODE_HITL (waits for human approval on the dashboard).
    • Adds HITL verdict forwarding: human approval decisions made on the Adrian dashboard are now forwarded inline to Claude Code integrations tagged with the CC source.
    • Adds PII filtering for the Claude Code plugin (integrations/claude-code/adrian_cc/pii/_patterns.py), detecting and redacting EMAIL, PHONE, SSN, CREDIT_CARD, IP_ADDRESS, DATE_OF_BIRTH, IBAN, PASSPORT, STREET_ADDRESS, POSTAL_CODE, DRIVER_LICENSE, and AWS_KEY categories from agent conversation content.
    • Adds a transcript parser (integrations/claude-code/adrian_cc/transcript.py) that reads Claude Code's JSONLJSONLA text format where each line is a self-contained, valid JSON object, making it easy to stream, append, and process large datasets line by line without parsing a full JSON array into memory. transcript to extract thinking blocks, user prompts, system prompt context, and invocation metadata, with mtime-based caching to avoid re-parsing on every hook call.

    5 details in Everything