Skip to content
    Gaincontrol

    Open source · Apache-2.0 · Beta v0.1.0b3

    Find the AI agents your code defines.

    Quin is an open-source CLI that scans your repositories to find the AI agents in them, extract each agent's system prompt, map the tools and models it reaches, and write a report your security pipeline can use. It's named after Bao Qingtian, the judge who saw through every deception.

    payments-service/ Scan complete: 2 agents · 2 MCP servers · 1 model endpoint

    • agents/refund_agent.py: agent · system prompt extracted
    • agents/triage_agent.py: agent · 3 tools linked
    • config/crew.yaml: CrewAI 0.152.0 · no OSV advisories
    • config/mcp.json: 2 MCP servers (stdio, http)
    • .env: 1 model endpoint · key redacted
    • README.md: no agent

    See what a scan returns.

    Point Quin at any repository, local or remote. No instrumentation, no agent-side changes — this is the report format the CLI writes to disk.

    quin-scannerCompleteSample scan
    $quin-scanner scan https://github.com/crewAIInc/crewAI-examples/tree/main/crews --output json
    ›resolving targetcrewAIInc/crewAI-examples · crews/
    ›running 13 scanners169 files · 343 findingsok
    ›inventory + coverageagents, tools, models, endpointsok
    ›framework detectedCrewAI 0.152.0found
    ›querying OSV.devframework and version onlyok
    ›pass 1/2 classificationoptional LLM passok
    ›pass 2/2 synthesis11 agents profiledok
    ›report writtenreport/crews_20260829_061859.jsonok

    report/crews_20260829_061859.json

    {
    "repo_path": "crewAI-examples/crews",
    "scan_timestamp": "2026-08-29T06:17:42.109475+00:00",
    "is_ai_application": true,
    "confidence": 0.99,
    "capability_tags": [
    "llm-api", "multi-agent", "orchestration",
    "prompt-templates", "rag", "tool-use"
    ],
    "framework": "CrewAI 0.152.0",
    "agents": [
    {
    "name": "Research Analyst",
    Trimmed from an example report

    From repository to report in one command.

    Point Quin at any repository, local or remote, and get a structured map of the AI agents it finds, what each is instructed to do, and what risks it carries.

    See how Quin scans
    1. AI indicator detection

      Scans dependencies, imports, config files, environment variables, and directory structures for signs of AI/ML library usage across any codebase.

      Frameworks and dependencies

      PythonNode.jsGoRustJava+ any AI/ML pattern
    2. System prompt discovery

      Extracts system prompts from Python source, YAML configs, and prompt template files, surfacing what your agents are actually instructed to do.

      System prompts

    3. Agent, tool, and endpoint inventory

      Maps the LLM endpoints your code calls (credentials redacted), MCP servers and their transports, and the tools explicitly passed to each agent in Python and JS/TS code, alongside a complete finding inventory and scan coverage.

      Agents · tools · MCP servers · endpoints

    4. LLM-powered intent analysis

      Optional

      Sends discovered prompts to an LLM (OpenAI, Anthropic, Google, Ollama, or any OpenAI-compatible endpoint) to summarize each agent's goal, capabilities, and risk signals.

      Goals · risk signals (T001–T014)

      OpenAIAnthropicGoogle GeminiOllama (local)OpenAI-compatible--no-llm for heuristics only
    5. Structured compliance reports

      Writes an interactive HTML report by default, or JSON, YAML, or SARIF for SIEM ingestion, compliance pipelines, or manual security review, with confidence scores and capability tags.

      HTML · JSON · YAML · SARIF

    6. GitHub Action with SARIF

      Run Quin on every push with the GitHub Action. Findings land in GitHub code scanning as SARIF, and in --no-llm mode no API key is needed.

      GitHub code scanning

    Open source

    Free forever. Self-hosted, no limits.

    Quin's scanner is Apache-2.0 licensed and free to use. Scan local folders, GitHub and Azure DevOps repos, or a whole GitHub org; run fully static with --no-llm; and add the GitHub Action to CI. Requires Python 3.11+.

    View on GitHub

    Enterprise edition

    SSO. A self-hosted dashboard.

    Everything in the open-source CLI, plus SSO authentication and a dashboard for tracking AI agent adoption across your organization. Like the CLI, it runs in your own environment.

    Talk to our team

    Frequently asked questions

    Quin surfaces unregistered agents in your code, system prompts that grant broad or risky capabilities, agent frameworks pinned to versions with published vulnerabilities (checked against OSV.dev), and the risk signals its LLM intent analysis finds in each prompt. It doesn't watch live traffic, so runtime attacks such as prompt injection are out of scope. At runtime, Zino checks every tool call against the agent's policy before it runs, so an injected instruction still can't make a call the policy doesn't grant.

    No. Quin runs entirely in your environment using your own LLM API key (Anthropic, OpenAI, Google, a local Ollama model, or an OpenAI-compatible endpoint such as vLLM, LiteLLM, or Azure OpenAI). Code and extracted prompts go directly from your machine to your chosen LLM provider for classification and synthesis, never to Gaincontrol. With --no-llm, no code or prompts go to any LLM. The vulnerability lookup still sends the detected framework name and version to OSV.dev, and to an advisory web search if you've configured a search provider. Add --no-vuln-check and a scan of a local repo makes no external calls at all (--vuln-search-provider none turns off only the web search). Remote targets are cloned first.

    No. Quin reads your repositories from the outside, with no code changes to your agents or pipelines.

    Yes. Quin reads source code rather than hooking into a framework at runtime. The 29 frameworks and SDKs it supports include LangChain/LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Google ADK, Strands Agents, Microsoft Agent Framework, Agno, Mastra, PydanticAI, LlamaIndex, Semantic Kernel, and MCP servers, and it also detects direct calls to the OpenAI, Anthropic, and Google SDKs.

    Quin is an early public release (v0.1.0b3) under active development. Like any static/LLM-assisted analysis tool, it can produce false positives and false negatives, and results should be independently reviewed before being used for security, compliance, or architectural decisions. Every finding in a report includes a confidence score so you can triage accordingly.
    All posts
    • · 2 min read

      Shadow agents and the missing agent inventory

      Many organizations can't produce a complete list of the AI agents running in their environment. The ones that matter most are the ones nobody registered.

    • · 3 min read

      A checklist for evaluating agentic AI security vendors

      "Agentic AI security" bundles three different disciplines under one umbrella term: visibility, identity, and execution. Most vendors selling under it only answer one of the three.

    • · 3 min read

      What is agentic AI security?

      "AI security" and "agentic AI security" sound like the same category. They're not. One centers the model; the other centers what the model is authorized to do once it can act.

    Quin reports the agents it detects, and with --detect-zino it also reports whether each repo is governed by Zino, only declares it, or is ungoverned. Zino governs who acts; Drona, in private development, will orchestrate what they do.

    Run your first scan.

    Install the CLI and point it at any repository. Add --no-llm for a fully static scan with no model calls.

    pip install quin-scanner
    quin-scanner scan ./your-repo