🦔 SmartPangolin

Scan before you share. Stop leaking secrets into AI models, agents, and tools.

IAIso §1 · Secure Sharing · SmartTasks.cloud · the Smart* family

You paste your repo into an AI. What did you just leak?

As AI reshapes how we work, a new gap opens: feeding code/docs to ai leaks secrets, keys, and internal detail. SmartPangolin closes it — scan at the exact moment the gap bites, and it works the second you clone it (a synthetic demo ships in demo/).

Install

SmartPangolin is not published on PyPI or any other package registry yet. Until this section says otherwise, a package called sf-smartpangolin on any registry is not ours, and neither is smartpangolin. The PyPI package pango is a placeholder published by someone else; it is not this tool.

Install from a clone (Python 3.8 or later):

git clone https://github.com/SmartTasksOrg/sf-smartpangolin
cd sf-smartpangolin
python -m venv .venv
. .venv/bin/activate          # Windows PowerShell: .\.venv\Scripts\Activate.ps1
python -m pip install .
sf-smartpangolin --demo

Status

• Version 3.0.0, experimental. A deterministic secret-scanning packager with 31 tests, including red-team regression cases; SECURITY.md lists what it does not detect.
• Published: nowhere yet; install from a clone (above).
• Tested: lint, the 31 tests and a sf-smartpangolin pack dry run on Linux, Windows and macOS with Python 3.8, 3.10 and 3.12, on every push to master and every pull request (.github/workflows/ci.yml).
• Not tested: Python 3.9, 3.11 and 3.13.
• Ports: Go, Java, Node and PHP ports in ports/ are checked against the Python reference by ports/conformance/run.sh (run by hand, not in CI); they are not published on any registry.
• Security review: none independent. Report vulnerabilities as described in SECURITY.md.

Run it in your stack

What's in this repo

• Core engine — src/sf_smartpangolin/: scan() -> ScanResult. Deterministic, dependency-free.
• CLI — sf-smartpangolin pack | verify | triage | tree | purge | policy | init, the full fail-closed packager. sf-smartpangolin --demo runs the quick demo; the family scan() API is the lightweight scanner.
• Language ports — ports/: native Go, Java, Node, PHP implementations that reproduce the Python reference, with a shared conformance harness.
• Integration kits — kits/: LangChain, LlamaIndex, function-calling, MCP, CI, and pre-commit starters.
• Adapters — adapters/: GitHub Action and language adapters.
• Framework integrations — integrations/: Flowise, VS Code extension — each a thin wrapper over one adapter.py bound to the core.
• MCP server — sf-smartpangolin-mcp console script, for agentic/AI-coding clients.
• Reference docs — docs/: 10 documents (CLI, policy, design, FAQ, porting…).
• Also included — a runnable demo/, examples/, the IAIso mapping spec/iaiso-map.json, a browser site/playground.html, plus public smoke tests in tests/.

How it works

Rule IDs are namespaced SEC-* so output looks kin to the rest of the family (SmartCheck's CHECK-*, SmartSeal's SEAL-*, etc.). Deterministic, dependency-free, fail-loud.

The data objects (UML)

These are real dataclasses in src/sf_smartpangolin/models.py — the diagram and the code are the same thing:

classDiagram
    class Finding {
      +rule: str
      +severity: str
      +path: str
      +detail: str
    }
    class Policy {
      +rules: list[str]
      +hash: str
    }
    class ScanResult {
      +findings: list[Finding]
      +verdict: str
      +policy_hash: str
    }
    class IAIsoControl {
      +section: str
      +name: str
    }
    ScanResult ..> IAIsoControl : conforms to

Where it sits in the architecture

SmartPangolin doesn't stand alone — it stacks with the family, and everything conforms to the IAIso standard — the same standard that governs SmartTasks' own apps, while each tool here stays standalone and drops into your architecture:

graph LR
    IAIso([IAIso standard]):::std
    Cloud([SmartTasks.cloud]):::cloud
    SmartPangolin[SmartPangolin]:::tool
    SmartPrompt[SmartPrompt]:::tool
    SmartCheck[SmartCheck]:::tool
    SmartSeal[SmartSeal]:::tool
    SmartStandard[SmartStandard]:::tool
    SmartSim[SmartSim]:::tool
    SmartMoat[SmartMoat]:::tool
    SmartRoute[SmartRoute]:::tool
    SmartFeed[SmartFeed]:::tool
    SmartPangolin -->|emits clean artifacts to| SmartSeal
    SmartPrompt -->|hands secret/PII flags to| SmartPangolin
    SmartPrompt -->|enforces prompt rules from| SmartStandard
    SmartCheck -->|stamps verified output with| SmartSeal
    SmartCheck -->|checks against rules from| SmartStandard
    SmartSeal -->|issues receipts consumed by| SmartCheck
    SmartSeal -->|issues receipts consumed by| SmartRoute
    SmartStandard -->|supplies rule sets to| SmartPrompt
    SmartStandard -->|supplies rule sets to| SmartCheck
    SmartSim -->|feeds role forecasts to| SmartMoat
    SmartSim -->|draws signals from| SmartFeed
    SmartMoat -->|consumes forecasts from| SmartSim
    SmartRoute -->|verifies receipts from| SmartSeal
    SmartRoute -->|enforces the standard from| SmartStandard
    SmartFeed -->|feeds signals to| SmartSim
    SmartFeed -->|feeds signals to| SmartMoat
    SmartPangolin -.conforms.-> IAIso
    SmartPangolin -.shares IAIso with.-> Cloud
    SmartPrompt -.conforms.-> IAIso
    SmartPrompt -.shares IAIso with.-> Cloud
    SmartCheck -.conforms.-> IAIso
    SmartCheck -.shares IAIso with.-> Cloud
    SmartSeal -.conforms.-> IAIso
    SmartSeal -.shares IAIso with.-> Cloud
    SmartStandard -.conforms.-> IAIso
    SmartStandard -.shares IAIso with.-> Cloud
    SmartSim -.conforms.-> IAIso
    SmartSim -.shares IAIso with.-> Cloud
    SmartMoat -.conforms.-> IAIso
    SmartMoat -.shares IAIso with.-> Cloud
    SmartRoute -.conforms.-> IAIso
    SmartRoute -.shares IAIso with.-> Cloud
    SmartFeed -.conforms.-> IAIso
    SmartFeed -.shares IAIso with.-> Cloud
    IAIso -.governs.-> Cloud
    classDef tool fill:#1c232d,stroke:#f5b83d,color:#efe9f5;
    classDef std fill:#04121f,stroke:#46d6c8,color:#46d6c8;
    classDef cloud fill:#1a1327,stroke:#a78bfa,color:#a78bfa;
    style SmartPangolin stroke-width:3px,stroke:#ff6b6b;

• SmartPangolin emits clean artifacts to SmartSeal →

Open site/playground.html for the interactive version.

Part of the Smart* family

One system, not nine projects — same mascot, same manifesto voice, same rule-ID style, all aligned to the IAIso standard. Each is an independent, open-source, single-purpose tool you can integrate into your own architecture:

Backed by the standard: SmartPangolin implements IAIso §1 · Secure Sharing. Open-source edition: this repo is the simplified, single-purpose version, built for any org to integrate into its own architecture. SmartTasks' desktop app and SmartTasks.cloud run a more advanced, deeply-integrated implementation of the same IAIso governance — a separate product, not this code bundled.

Who's behind this

• Roen Branham — CEO & AI Strategy Architect · CISSP-certified AI, security & governance architect; author of IAIso and sole inventor of the Z4 Semantic Fabric patent application. LinkedIn
• Le Vu Tanh — CTO & Core Engineering Lead · Chief architect of the Cortex engine; large-scale system reliability and low-latency infrastructure — the engineer who ships what gets architected. LinkedIn

The team behind IAIso & SmartTasks: a CISSP-certified security & governance architect and a large-scale systems engineer — 20+ years shipping secure, AI-driven platforms for regulated, blue-chip environments (Allianz, BMW, Rolls-Royce, Heidenhain).

Runs on governed local models

Every build ships SHA256SUMS and a supply-chain + red-team scan — the same provenance discipline SmartPangolin enforces on your repos.

This tool is local-first, so pair it with models you can actually vet. SmartTasks publishes 21+ governance-validated GGUF builds on Hugging Face — each with a machine-readable scorecard (capability tiers L1 Layman → L5 Agentic, IAIso conformance invariants (pass/warn/fail), OWASP-mapped garak red-team, transparency probes (viewpoint-alignment / over-refusal), and per-file SHA-256). Gate model selection on evidence, not vibes — and every finding, including warnings, is published in full.

→ SmartTasks on Hugging Face · Qwen3.6-27B (L5 agentic) · react-agent-coder-llama-3.1-8b (agentic coder) · gpt-oss-20b (open reasoning)

Get in touch

• Companies & enterprises: enterprise@smarttasks.cloud — we help teams integrate SmartPangolin + IAIso into their architecture so governance and audit-readiness become a byproduct of how they already work.
• The standard: IAIso · iaiso.org
• The product: SmartTasks.cloud

Built by SmartTasks Lab. Apache-2.0. Contributions welcome.

Measured effectiveness (benchmarked)

SmartTasks tests this tool against live local models, not just unit fixtures. Headline recall across difficulty levels: 100%.

How to read this. These come from the Smart* effectiveness benchmark: a local model is driven to produce content of increasing difficulty; the tool (detects secrets (API keys, private keys, dangerous files), including base64/hex-encoded ones) is then run and its verdict scored against an independent oracle (broader than the tool's own rules, so a miss is a real gap).

• Recall — of cases that genuinely contained the target, the share the tool caught. Low recall = coverage gap.
• Precision — of what the tool flagged, the share that were real problems. Below 100% = false positives.
• Levels — 0 canary · 1 basic · 2 realistic · 3 obfuscated · 4 adversarial (hardest).
• Invalid — the model failed to produce the scenario (e.g. emitted a placeholder, not a real secret); not scored, so the tool is neither credited nor penalized.
• Sample size — model output varies run-to-run; small n is noisy. Pooled numbers combine recent runs.

What this run shows:

• Instrument check (canary) passes — the fixed sanity cases are all correct, so the higher-level numbers are trustworthy.
• Strong at: basic, realistic, obfuscated, adversarial — near-complete recall.
• No false positives observed (precision 100%) — the tool does not flag clean input.

Source: run 20260804T134233-fad704 · 2026-08-04T13:45:23 · model(s): llama-3.1-8b-lexi-uncensored-v2 · repeats 8. Numbers reflect these model(s); output varies run-to-run, so re-run and regenerate to refresh.