Three models. One brain. Trained only on what attackers actually do.
A single general-purpose model is the wrong tradeoff curve for security work, latency, precision and cost pull in different directions, and one set of weights can't sit at all of those optima. The lineup splits the work: Griffin spends a real reasoning budget proving and disproving each candidate, Eagle sweeps the repo and ranks them, Lion handles inline checks, and Zero answers the questions that never needed a model at all.
One curve doesn't fit precision, latency, and cost.
Each model occupies a different point on the security tradeoff curve. You don't pay for reasoning you don't need and you don't wait for latency you can't spend.
Fast or it's not inline
A model that takes two seconds to think is a model the developer disables. Lion is a small model sized for quick answers, every other choice flows from that constraint.
Wide angles need ranking, not reasoning
Sweeping a repo for taint candidates is a clustering problem, not a chain-of-thought problem. Eagle's head is fine-tuned for ranking dataflow tokens — fast, batched, and cheap enough to run across every package on every commit.
Precision requires reasoning budget
Hypothesising an exploit chain and trying to refute it under sanitiser constraints is genuinely hard. Griffin gets the parameter count, the context window, and the chain-of-thought depth to earn its verdict.
Most questions are not a reasoning problem
A large share of what people actually ask is a shape, not a puzzle — an entity, a filter, a count, a breakdown. Sending those to a language model buys nothing and costs a round trip, a token bill and a copy of the question leaving the building. Zero reads them in process and answers from structure alone.
Griffin · Eagle · Lion · Zero — one corpus, four speeds.
Griffin
01Deep reasoning · the hypothesis engine.
- 750B parameters
- Security-augmented tokeniser (CWE-IDs, CVE-IDs, taint-source tags, dataflow operators)
- 1.1M-token context window for multi-hop call graphs
- Multi-step chain-of-thought with adversarial disproof pass
- Distillation source for both Eagle and Lion
- Curated CVE bodies and accompanying patch diffs
- Exploit write-ups and public proof-of-concept code
- Vulnerability disclosure threads and security advisory text
- Malware behavioural traces and reverse-engineering notes
- IDA / Ghidra disassembly excerpts with annotations
- Cross-package taint graphs extracted from open-source repos
- MITRE ATT&CK mappings, security RFCs, package registry metadata
Published evaluations for Griffin will appear here once they are measured.
Eagle
02Wide-angle triage · the surface scanner.
- 70B dense transformer, distilled from Griffin
- Ranking + clustering head fine-tuned for taint-path prioritisation
- Attention biased toward dataflow tokens (sources, sinks, sanitiser ops)
- Batched inference optimised for full-repo sweeps
- Same security-augmented tokeniser as Griffin
- Taint graphs and call-graph slices labelled for reachability
- SAST findings with ground-truth exploitability labels
- Fuzzing corpora and crash-derived input grammars
- Sanitiser configurations from real-world projects
- Package registry metadata with version-pinned advisories
- CWE-class labelled patch sets
Lion
03Inline · the commit-time gut check.
- 15B parameters, distilled from Griffin via security-task distillation
- Small, fast model served through Safeguard's API, built for inline checks
- Optimised for low-latency inline checks
- Same security-augmented tokeniser; pruned to inline-relevant vocab
- Reached from the IDE extension and CLI through Safeguard's API
- Distillation traces from Griffin on common sink + sanitiser pairs
- Hand-labelled inline patterns for unsafe deserialisation, command injection, SSRF, path traversal, prompt injection
- Sanitiser-aware negative examples to suppress noise
- Public-only training; no customer code, ever
Zero
04No inference · the question, read in place.
- No model weights and no inference — semantic analysis, not generation
- Reads the prompt into the platform's own query grammar: entity, filters, joins, aggregation
- Deterministic — the same question always produces the same query, so an answer can be cached, replayed and audited
- Refuses rather than guesses; when it does infer, the answer is labelled as an approximation with what it understood
- Runs in process, so the prompt never leaves the platform
- No training corpus — there are no weights to train
- The platform's own entity and field vocabulary, read from the schema rather than memorised
- Synonyms and phrasings mapped to that vocabulary by hand, and versioned with it
- Nothing is learned from customer prompts, because nothing is learned at all
Eagle scores, Griffin proves.
Every finding gets a complexity score from Eagle first, so Griffin's reasoning budget goes to the chains that need proving, not to one-hop sinks.
Eagle assigns each candidate a complexity score from the call graph: depth, sanitiser ambiguity, cross-package edges, sink severity.
Griffin runs the hypothesise → cite → disprove → patch trace. The trace ships with the finding so reviewers can audit how it was reached.
Architecture details, not marketing copy.
Security-augmented tokeniser
Around 28k extra tokens cover CWE / CVE identifiers, taint operators, package coordinates, and attack-pattern shorthand. Names like preg_replace, ObjectInputStream and pkg:npm/lodash do not shatter into byte-pair noise — their embedding-space neighbours are other vulnerable patterns.
Long context, retrieval-augmented
Sliding-window attention plus landmark tokens keep long call graphs coherent inside Griffin's 1.1M-token context window. The call-graph chunker retrieves the slice of the program that matters for a given finding and pages it in around the hypothesis, so context is full but coherent.
Structured reasoning trace
Every Griffin call emits a four-stage trace: hypothesise the exploit, cite the path in the call graph, propose a disproof, propose a patch. The trace is the finding — reviewers see the chain, not a single label, and can reject at any stage.
Security-domain RLHF
Preference data is labelled by senior offensive-security engineers, not generic annotation vendors. The reward model penalises plausible-sounding hallucinations on CWE classification and treats unverified reachability claims as failures.
Distillation source for the lineup
Griffin is the teacher for Eagle and Lion. Their behaviour stays consistent with Griffin's reasoning on the same finding — they are smaller, faster heads of the same brain, not a different model trained to imitate.
Where each tier actually runs.
The lineup is the same brain at four isolation levels. Pick the shape that matches your data-residency and trust boundary; the models stay consistent.
Shared cloud
Multi-tenant inference, fastest onboarding, per-tenant isolation at the prompt and KV cache layer. Best for teams trialling the lineup.
Dedicated cluster
Single-tenant inference on isolated VPC hardware. No cross-tenant traffic, deterministic latency, full SHA-pinned weight attestation.
VPC-isolated
Customer-controlled VPC, bring-your-own-key encryption, no cross-tenant traffic. Inference plane sits inside your network perimeter.
Sovereign / air-gapped
STQC-ready, no internet egress, on-prem GPU, full audit-log export. Suits regulated, classified, and sovereign deployments.
Commit to queue, one pipeline.
Inline sink + sanitiser check on the selected code, through Safeguard's API.
Cross-package taint paths ranked across the codebase.
Deep reasoning posits an exploit chain + CWE class.
Second pass tries to refute; survivors land in your queue.
Every survivor lands in your queue with the taint path, hypothesised trigger, disproof attempt log, and a ranked evidence bundle.
Why the corpus matters more than the parameter count.
Refusal rates drop when the corpus knows you're a defender.
General-purpose models are trained to flinch at the word 'exploit'. Ours are weighted on disclosures, write-ups, and patch diffs — the literature of defenders — so a question about a deserialisation gadget gets answered, not refused.
The tokeniser speaks security.
CWE-IDs, CVE-IDs, taint-source tags, and dataflow operators are first-class tokens, not stochastic fragments. Sink names like preg_replace and ObjectInputStream don't shatter into byte-pair noise. Embedding-space neighbours are other vulnerable patterns, not unrelated English.
No contamination from marketing copy or unframed code.
General code corpora are dense with patterns that look secure to a model trained on README files and tutorials but ship CVEs in production. We deliberately exclude product copywriting, StackOverflow snippets without a security frame, and any code lifted without disclosure context.
RLHF rubric written by security engineers.
Reward modelling is graded against a rubric that penalises plausible-sounding hallucinations on CWE classification, rewards explicit reachability reasoning, and treats unverified claims as failures. The rubric is owned by the security team, not a generic annotation vendor.
Closing the loop with the engine.
Every finding the deterministic taint engine surfaces becomes a structured brief the model sees in inference. The model doesn't have to guess at reachability — it inherits it. That hybrid is what keeps the false-positive rate honest.
What's NOT in the corpus
The exclusion list is contractual, not aspirational. Every item below is audited at ingest.
- No customer code — ever, at any tier.
- No general web crawl or social media text.
- No PII, secrets, or scraped credentials.
- No closed-source proprietary disassembly.
- No LLM-generated synthetic security text.
- No product copywriting or vendor marketing.
- No StackOverflow snippets without a security frame.
What IS in the corpus
Defender-frame data, deduplicated and labelled. The ingest manifest is reviewable under NDA.
- CVE descriptions plus patches with linked diffs.
- Exploit write-ups and POCs, curated and deduplicated.
- Vendor advisory texts (CERT, MITRE, vendor PSIRT).
- Static-analysis findings with ground-truth labels.
- Taint graphs extracted from open-source repos.
- MITRE ATT&CK technique descriptions and procedure examples.
- Fuzzing corpora and crash triage notes.
- Package-registry metadata and malware behavioural traces.
- IDA / Ghidra disassembly excerpts, security-tagged.
- Vulnerability disclosure threads, with consent.
- Security RFCs and standards (NIST, ENISA, OWASP).
Guarantees in writing.
Tenant-level commitments
- Customer code never enters training — contractual, audited, and per-tenant attested.
- Per-tenant inference isolation; no cross-tenant prompt or KV cache reuse.
- Full model + dataset attestation available under NDA, including SHA-pinned weights.
- Opt-out for any analytics signal contributing to evaluation telemetry.
- Export-controlled deployments available for federal customers (FedRAMP HIGH / IL5 path).
- Coordinated disclosure with upstream maintainers stays opt-in per finding.
Numbers next to the alternatives.
Same internal eval suite, run against a leading general-purpose model and a representative pure-LLM bug hunter. Lower is better for FPR, latency, and refusal; higher is better for resistance and recall.
| Stack | False positive rate | Adversarial prompt resistance | Cross-package taint path recall | Latency p95 (inline), not yet published | Refusal rate on security Q&A |
|---|---|---|---|---|---|
| General-purpose LLM (zero-shot) | 62% | 41% | 18% | 1.8 s | 34% |
| Pure-LLM bug hunter (Mythos-class) | 54% | 63% | 37% | 2.4 s | 11% |
| Safeguard Lineup (Lion + Eagle + Griffin) | 6% | 98% | 94% | Not published | <1% |
The rest of the platform this plugs into
The work this actually does
Self-healing security runs on Safeguard.
Your first fix PR is minutes away.
No sales call required, even your agent can complete the purchase over MCP.