THE SIGNAL IN ONE SENTENCE

Security agents have a familiar problem. They can read a lot of code and still have no honest idea what they missed. Semgrep has announced Mandoline, a research preview of program-analysis tools designed to sit inside an AI agent's reasoning loop. The pitch is not that Mandoline finds a vulnerability and hands over a perfect verdict. Its job is narrower and more useful: answer specific questions about the code so an agent can reason from evidence. Where can an attacker enter the application? Which functions can this route reach? Where does this value flow? Can tainted input arrive at a dangerous sink? Which dependencies sit on the path? What parts of the graph remain unresolved? Semgrep says Mandoline can provide facts about call graphs, data-flow trees, taint paths, exposed surfaces and dependency reachability. It supports text, JSON, Graphviz and protobuf outputs, with CLI, MCP and gRPC interfaces. The company describes interfile and deep-analysis support across 50 languages, including application languages, infrastructure files and several SQL dialects. The architecture has first-class bindings for six languages plus WebAssembly, and runs on Mac, Linux, Windows and WASM. Those are the verified product claims. Semgrep also reports large speed improvements, broad test-suite coverage and strong benchmark scores. It says Mandoline is 15 to 50 times faster than its Pro engine in selected checks, passes more than 36,000 C++ and Java tests from the NIST Juliet suite, and scores 100 percent on the Java OWASP Benchmark and 98.28 percent on its Python benchmark. The company adds an unusually important footnote: its OWASP benchmark result has very little correlation with performance on private real-world codebases. Keep that sentence. The plain-language signal is simple. A code map is valuable when it shows where the roads go. It becomes trustworthy when it also shows the fog, the broken bridges and the neighborhoods it never entered. Publish where the map goes blank. Start with the agent's question. Program analysis is not one giant answer called secure. It is a collection of specific queries about a codebase. Store the exact question the agent asked, the tool command, the repository commit, the file and line where analysis began, the configuration and the tool version. If an investigation starts at an API route, say so. If it starts at a suspicious variable, say so. A graph slice from one entry point should not quietly become a claim about the entire application. Then preserve the returned facts. Each call edge, data-flow step and taint path should point back to code a reviewer can inspect. Include source locations, resolved symbols and the reason the tool connected one node to another. Mandoline's announcement says it provides code as evidence and can report analysis limitations, such as whether full type resolution was available for a graph edge. That is the right instinct. The map should make confidence local. One edge may be resolved through a concrete function call. Another may be inferred because a framework registers routes dynamically. Another may be missing because reflection, generated code, native extensions or runtime configuration hid the relationship. Do not compress all of that into one confidence score. Label the edge. Show whether the relationship was directly resolved, conservatively inferred, supplied by a framework model, imported from dependency metadata or left unresolved. Then show coverage. List the languages parsed, frameworks modeled, templating systems understood, build outputs included and dependencies available. List the ones that were not. Fifty languages is broad coverage. It is not the same as complete understanding of every framework, metaprogramming trick, generated client, database procedure or runtime plugin written in those languages. A modern application can cross TypeScript, Java, SQL, Terraform, shell scripts, containers and cloud configuration before breakfast. The analysis receipt should show where the path crossed a language boundary and whether the tool followed it. If a Java handler writes a value to a database and a Python worker reads it later, the blank between those programs matters. If a templating engine escapes a value at runtime, the framework model matters. If a route exists only through configuration, a call graph built from ordinary calls may never see it. Blank space is not failure by itself. Hidden blank space is the failure. Now record the explored surface. Semgrep notes that a tool inside the agent flow can track which parts of a code graph the agent explored and which paths remain untouched. That turns coverage into an observable object rather than a feeling. Build an exploration ledger. For each run, record entry points, reachable nodes, paths traversed, paths pruned, time limits, token limits, tool errors and branches the agent chose not to investigate. Display unexplored paths beside findings. A report that says three vulnerabilities found should also say how much of the attack surface was analyzed and which regions remain uncertain. Otherwise every security agent becomes a metal detector on a beach claiming the sand is clean because it found three bottle caps. Next, separate facts from findings. Mandoline is deliberately designed to surface code facts rather than final vulnerability findings. That division is healthy. A fact might be: untrusted request input can reach this database function through these calls. A finding adds interpretation: the path is exploitable, the controls are insufficient, the severity is high and a developer should change the code. The agent may make that interpretation. A security engineer may agree or reject it. Keep both layers visible. Do not let the agent rewrite the tool's result into a more certain sentence. Store the original structured output, the agent's explanation, the evidence it cited and the final human decision. If the agent ignored a limitation reported by the tool, highlight the mismatch. Then test disagreement. Run the same investigation with another tool, a compiler, tests, runtime tracing or a focused human review. Differences are useful. Static analysis can over-approximate paths that cannot happen at runtime. It can miss behavior created dynamically. A model can misunderstand correct tool output. A human can overlook a tedious path. Independent methods fail differently. The review should ask: Did both tools identify the same entry points? Did they resolve the same calls? Did they disagree about sanitization? Was a missing path caused by configuration, unsupported syntax or a time limit? Which evidence would settle the question? Do not vote by tool count. Investigate the disagreement. Now add a stopping rule. Security agents can always spend more tokens, search another file and generate another hypothesis. Semgrep describes the frustrating slot-machine quality of repeated model runs, where each attempt finds a different collection of issues. A deterministic code map can reduce wandering, but it does not automatically tell the agent when the work is done. Define completion before the run. For an API review, completion might require every externally reachable route to be enumerated, every high-risk source-to-sink category checked, every unresolved call recorded and every critical finding reproduced. For a patch review, completion might mean the changed files, their reachable callers, affected tests and dependency changes were analyzed. For a vulnerability class, completion might require coverage across named entry points, frameworks and languages, plus an explicit list of exclusions. The final report should say complete against this scope, not secure. No serious codebase earns a one-word security diploma. Performance claims need their own receipt. Semgrep reports that a scan over 34 open-source repositories with 2,955 rules took 156 minutes in Semgrep Pro, 2.4 minutes with Mandoline and 10 seconds with a warm cache. It also reports recurring gains of 15 to 50 times in selected agent-relevant analysis. Those numbers may be excellent. They depend on repositories, rules, cache state, hardware, configuration and the work each engine performed. Measure cold and warm runs separately. Record index time, query time, peak memory, cache size and invalidation behavior. Check whether an apparently fast repeat run reused stale facts after code changed. Speed matters inside an agent loop. Correctness after a branch update matters more. Benchmark results need the same treatment. Publish the suite, version, configuration, pass criteria and known mismatch with production systems. A perfect score on a benchmark should not become a perfect score for a private monorepo with custom frameworks and ten years of accidental architecture. Use benchmarks to catch regressions. Use representative internal cases to decide whether the tool belongs in the workflow. Build a shadow set from past vulnerabilities. Take confirmed issues from the organization's own history, remove the fixes and ask whether the combined tool and agent workflow can rediscover them. Include false positives that previously wasted developer time. Do not train the workflow on the answers and call the result validation. Then test the dangerous edges. Use reflection, dependency injection, route registration, code generation, templates, database persistence, message queues, infrastructure configuration and cross-service calls. Include places where the source and sink live in different languages. Test incomplete repositories. Agents often receive a shallow checkout, missing submodules, unavailable generated files or dependencies without source. The correct result may be unable to resolve this path because these inputs are missing. That sentence is better than a confident fantasy. Tool access also needs boundaries. Mandoline can be exposed through interfaces that fit agent harnesses. An MCP or gRPC connection is still an execution boundary. Limit repositories, branches, commands and output paths. Keep credentials away from code the agent can read. Log queries and results. Prevent untrusted repository content from rewriting system instructions or expanding tool permissions. A malicious README should not be able to convince a security agent to upload the repository somewhere helpful. For private code, define retention and access for the analysis graph itself. A call graph, dependency path or list of exposed endpoints can be sensitive even without full source code. Then preserve human authority. An agent can prioritize, trace and explain. It should not silently close a vulnerability, approve a release or dismiss an unresolved path without an accountable reviewer for consequential systems. Give the reviewer the code evidence, tool limitations, agent reasoning, alternative hypotheses and reproduction status. Make rejection useful. When a human marks a finding false or incomplete, capture the reason and feed it into tests, framework models or routing rules rather than merely lowering a dashboard count. The most useful output from an agentic security system may be a map of uncertainty. It can show where evidence is strong, where the tool made conservative assumptions, where the model spent time, where the repository crossed unsupported boundaries and where a human should look next. That is not as dramatic as autonomous vulnerability hunting. It is more useful than another robot confidently declaring mission accomplished. Semgrep Mandoline is a research preview. Its architecture points toward a sensible hybrid: models for investigation and explanation, deterministic tools for code facts, compilers and tests for verification, and humans for accountable decisions. The system earns trust when every layer leaves a receipt. Publish the question. Publish the evidence. Publish the limitations. Publish the unexplored paths. Then the code map can guide an investigation without pretending the fog is empty.

01

WHAT ACTUALLY CHANGED

Semgrep announced Mandoline on November 12 as a research preview of program-analysis tools designed for AI agents.

Mandoline exposes code facts about call graphs, data flow, taint paths, exposed surfaces and dependency reachability.

Semgrep says the engine supports interfile and deep analysis across 50 languages, frameworks, infrastructure files and SQL dialects.

The library-first architecture has native bindings for six languages plus WebAssembly.

Interfaces include CLI, MCP and gRPC, with structured and visual output formats.

Semgrep says Mandoline provides code as evidence and reports limitations such as incomplete type resolution.

The company reports selected speed gains, test-suite results and benchmark scores for the research engine.

Semgrep also says OWASP benchmark performance has little correlation with results on private real-world codebases.

02

WHY THIS MATTERS

AI agents can spend large token budgets exploring code without knowing which paths remain unexamined.

Deterministic code facts can ground agent reasoning and make security claims easier to inspect.

Language coverage does not guarantee complete framework, runtime or cross-service understanding.

A correct tool result can still be misinterpreted or exaggerated by an agent.

Coverage, unresolved paths and analysis limitations matter as much as the vulnerabilities that were found.

Security decisions still need reproducible evidence and accountable human review.

FIG. 645THE CODE-MAP LIMITATION RECEIPT
1NAME THE QUESTION AND COMMIT→
2MARK ENTRY POINTS→
3TRACE EDGES TO CODE EVIDENCE→
4LABEL INFERENCE AND UNCERTAINTY→
5SHOW LANGUAGE AND FRAMEWORK GAPS→
6RECORD EXPLORED AND UNEXPLORED PATHS→
7REPRODUCE IMPORTANT FINDINGS→
8HAND THE DECISION TO A HUMAN
A security agent's map is reviewable when every path has evidence and every gap, exclusion and unresolved edge remains visible.

03

WHERE IT COULD HELP

  • Store the exact agent question, repository commit, tool command and starting location.
  • Link every call edge, data-flow step and taint path to reviewable code evidence.
  • Label directly resolved, inferred, framework-modeled and unresolved graph edges separately.
  • Publish supported and unsupported languages, frameworks, templates and runtime behaviors.
  • Track entry points, paths explored, paths pruned, errors and time or token limits.
  • Display unexplored regions beside vulnerability findings.
  • Preserve structured tool output separately from the agent's interpretation.
  • Investigate disagreements with compilers, tests, runtime traces, other tools and human review.
  • Define completion against a written scope before the investigation begins.
  • Measure cold and warm performance, cache state, memory and invalidation after code changes.
  • Test against confirmed historical vulnerabilities and costly false positives.
  • Include reflection, code generation, queues, persistence and cross-language paths in evaluation.
  • Restrict agent interfaces by repository, branch, command, credential and output destination.
  • Require human authority for closing findings, approving releases and accepting unresolved paths.

KEEP A HAND ON THE WHEEL

Mandoline is a research preview, not a proof that a codebase is secure or completely explored. Speed, coverage, benchmark and vulnerability-discovery figures in the announcement are company-reported and depend on selected repositories, rules, cache state and configurations. Semgrep explicitly says its strong OWASP benchmark result has very little correlation with performance on private real-world codebases. Support for 50 languages does not imply complete coverage of every framework, generated component, runtime behavior, dependency or cross-service path. Program analysis cannot be perfectly sound and complete for most useful properties. Mandoline says its bias is toward recall, which can increase conservative paths and false positives. An agent can misread accurate code facts, ignore limitations or make an unsupported severity claim. Consequential findings still need reproduction and accountable human review. Original announcement date: November 12, 2026. Verified November 13, 2026.

04

TERMS WORTH KEEPING

SOURCES AND VERIFICATION STATUS

This article was written from the materials below. Product claims and dates were checked against those sources on November 13, 2026.

THE PUBLICATION ENGINE

WANT A SIGNAL OF YOUR OWN?

We build source-grounded publications, private briefings, and editorial systems for organizations with something useful to say.

WORK WITH US