AI agent security · static analysis · private beta

See what your agent can actually do.

Inkog reads your agent's code and traces the paths from untrusted text (a user message, a web page, a tool result) to real actions. Then it shows you the ones nobody meant to allow: prompt injection into tools, runaway loops, actions with no human approval.

No self-serve signup. A person reads every request.

Fig. 1 · An example support agent, as Inkog maps it
TEXT INACTIONS OUTuserdocswebtool outplannermemorysearchemailrefundsqlshell
CRITICALsupport/agent.py:88

Text from any web page can trigger a refund.

tools=[fetch_url, search_kb, issue_refund]

Nothing sits between the model’s output and issue_refund(): no approval step, no amount limit.

OWASP ASI01 goal hijack · ASI02 tool misuse · EU AI Act Art. 14 if high-risk

Illustrative agent. The three patterns are the ones we see most often in real repositories; a real one is below.

01 — Why this exists

The lethal trifecta lives in your code, not your prompt.

  1. Untrusted text steers the agent.

    A support ticket, a web page or a tool result can rewrite what the agent does next. That is prompt injection; OWASP calls the agentic version goal hijack and tool misuse.

  2. The danger is the combination.

    Private data, untrusted content and a way to send things out: what Simon Willison calls the lethal trifecta. Each piece is harmless alone. The path between them is the bug, and it usually spans several files.

  3. Someone will ask you to prove it.

    Customer security reviews, the OWASP Top 10 for Agentic Applications and the EU AI Act’s human-oversight rules all ask the same question: where are the controls?

02 — What Inkog looks for

36 checks, sorted by the questions security teams actually ask.

They cover the agents you build and what your developers' coding agents load: MCP servers, Agent Skills and AGENTS.md files. Every finding names the file, the line and the path behind it.

Can someone else steer it?

  • Prompt injection from user input, documents, web pages and tool results into tools
  • System prompt leakage
  • Prompt templates built from untrusted text
  • Conflicting goals between delegating agents

OWASP LLM01 · ASI01 goal hijack

What can it do without asking?

  • Irreversible actions with no human approval
  • Tools with more permissions than the task needs
  • Missing authorisation checks before tool calls
  • Model-written code or shell commands run unsandboxed
  • SQL and command injection via model output

OWASP LLM05 · LLM06 excessive agency · ASI02 · ASI05 · EU AI Act Art. 14 (high-risk)

Can data get out?

  • Exfiltration paths: outbound requests built from model output (SSRF)
  • Cross-tenant leaks through shared memory and RAG
  • Retrieval with no cap on documents or size
  • Secrets and personal data in code, prompts and logs

OWASP LLM02 · the lethal trifecta

What did we plug into it?

  • MCP servers: tool poisoning, over-broad tools, unverified sources
  • Agent Skills: poisoned instructions, excessive permissions, cross-origin calls
  • Unpinned models, tools and configs loaded at runtime
  • Unsafe deserialisation of checkpoints and memory

OWASP ASI04 supply chain · LLM03

Will it run away?

  • Loops the model controls, with no cap or timeout
  • Token bombing and context exhaustion
  • Recursive tool calls and delegation cycles
  • No rate limits on model or tool calls

OWASP LLM10 unbounded consumption

Can we prove it’s under control?

  • Agent actions that leave no audit trail
  • Unauthenticated messages between agents
  • AGENTS.md declarations that don’t match the code

OWASP ASI07 · EU AI Act Art. 12 & 14 (high-risk)

03 — Where it fits

Security for MCP, Agent Skills, AGENTS.md and A2A.

The frontier labs are standardising how agents reach tools and each other. Inkog checks those connections in your code, and runs where you already build.

MCP

Model Context Protocol, from Anthropic

Inkog runs as an MCP server inside Claude Code, Claude Desktop, Cursor and VS Code, and audits the MCP servers your agents connect to: tool poisoning, over-broad tools, unverified sources.

Agent Skills

Skills format, from Anthropic

Scans Skills before an agent loads them: poisoned instructions, excessive permissions, cross-origin calls and autonomy abuse.

AGENTS.md

Instruction file read by Codex, Cursor and others

Checks that what your AGENTS.md promises, such as approvals, limits and logging, actually exists in the code.

A2A

Agent2Agent protocol, from Google

Audits delegation between agents: handoff loops, privilege escalation and messages nobody authenticates.

Agent SDKs

OpenAI, Anthropic, Google, Microsoft, Salesforce

Reads agents built with the OpenAI Agents SDK, the Anthropic SDK, Google ADK, Microsoft Copilot Studio, AutoGen and Semantic Kernel, Salesforce Agentforce, LangChain, LangGraph, CrewAI, n8n and more.

Inkog is independent and not affiliated with Anthropic, OpenAI, Google or Microsoft. The MCP server and GitHub Action work for beta partners while the hosted engine is in private beta.

04 — What we've seen

561

open-source agent repositories scanned, from LangChain and CrewAI to research agents.

789

findings the engine rated exploitable, out of 11,705. The rest were structural risks or hardening. Automated, not reviewed.

73/73

findings confirmed by hand on a 24-repository set we tuned the engine against (Feb 2026).

Fig. 2 · From a real scan · MetaGPT, public repo
examples/build_customized_agent.py
  1. 28prompt = self.PROMPT_TEMPLATE.format(instruction=instruction)user text enters the prompt
  2. 30rsp = await self._aask(prompt)↳ the model writes code
  3. 32code_text = SimpleWriteCode.parse_code(rsp)↳ extracted, never checked
  4. 48subprocess.run(["python3", "-c", code_text], ...)↳ runs on the host

CRITICAL

Model-written code runs on the host. No sandbox, no approval.

It's an example file, which is the point: examples are what people copy into production. The path crosses three methods; no single line looks wrong.

OWASP ASI05 · LLM05:2025

Most of the rest had structural risks rather than exploits: loops without a cap, tools without an approver. We tell you which is which, because a report full of maybes is how security tools get ignored. Read the study.

05 — How a walkthrough works

One call. Your code. A report you keep.

  1. 01

    30 minutes

    You show us the agent and what it’s allowed to do. We tell you honestly whether Inkog will help.

  2. 02

    One scan, together

    We run Inkog on your code with you. Secrets are redacted on your machine before anything is analysed.

  3. 03

    Your report

    Every finding with its path, file and line, a suggested fix, and the OWASP and EU AI Act controls it maps to. You keep it.

The CLI is open source, and the docs describe every check.

Fig. 3 · Inkog Deep (AI-assisted) on our deliberately vulnerable demo agent · replayed from a saved run
27 files · 26 findings

$ inkog -deep .

✓ Collected 27 files

✓ Redacted secrets from 27 files

EXPLOITABLE VULNERABILITIES (18)

  • └Hardcoded API Keys and DB Credentials [finance_agent.py:33] CRITICAL
    EU AI Act Art. 15.3 · NIST GOVERN 1.7
  • └OS Command Injection via Unsafe Shell Tools [agent.py:24] CRITICAL
    EU AI Act Art. 15.3, 15.4 · NIST MEASURE 2.6
  • └Financial Transactions Without Human Oversight [agent.py:65] CRITICAL
    EU AI Act Art. 14.1, 14.4 · NIST GOVERN 4.1
  • └Cross-Tenant Data Leakage via Shared Global State [agent.py:35] CRITICAL
    EU AI Act Art. 10 · NIST GOVERN 1.2
  • └Direct Prompt Injection in System Prompts [agent.py:15] HIGH
    EU AI Act Art. 15.3 · NIST MAP 3.5
  • └LLM-Generated SQL Injection in Database Queries [agent.py:35] HIGH
    EU AI Act Art. 15.3 · NIST MEASURE 2.6
  • └…and 12 more

RISK PATTERNS (8)

  • └Recursive Agent Delegation Without Cycle Guards
  • └Unbounded Context Window Accumulation in Agent Loops
  • └Missing Audit Logging for High-Risk Actions
  • └…and 5 more

26 findings · policy: balanced

18 exploitable vulnerabilities · 8 risk patterns · 6 of them also governance gaps

What the scan prints. Your report adds the path, the code and a suggested fix for each finding.

07 — Straight answers

What is Inkog?
Static analysis for AI-agent code. It builds a map of what the agent can do — model calls, tools, loops, memory, delegation — and flags the paths that need a limit, a check or a human: prompt injection into tools, loops the model controls, data crossing between users, and irreversible actions with no approval. An optional AI review pass (Inkog Deep) then reads the flagged code in context to explain each finding and cut noise.
Can I sign up and run it myself?
Not right now. We work with a small number of teams at a time and run every scan together, so we can stand behind the findings. The CLI is open source, so you can read exactly what leaves your machine. It needs our hosted engine, which only runs for beta scans right now.
How is it different from Semgrep, Snyk, MCP scanners or an LLM code reviewer?
SAST tools look at lines and known bug classes. MCP scanners check tool descriptions and configs. Inkog models the agent’s own code: which text reaches which model, which model output reaches which tool, and what stops it.
Does it cover coding agents like Claude Code and Cursor?
It checks what they load and trust: MCP servers (tool poisoning, over-broad tools), Agent Skills (poisoned instructions, excessive permissions) and AGENTS.md files that claim controls the code doesn’t have.
What does it cost?
Nothing during the beta. We ask for honest feedback on the findings in return.

Building an agent that can touch something real?

Tell us what it does. If Inkog isn't the right fit, we'll say so on the call.