Safeguard
Model family · weighted for cybersecurity

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.

◐ gravitational lensing · every path bends through the core
Why more than one model

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.

The lineup

Griffin · Eagle · Lion · Zero — one corpus, four speeds.

Safeguard's models
ModelParametersContext windowInput per 1M tokensOutput per 1M tokens
Griffin750B1.1M$0.0001$0.0001
Eagle70B1M$0.00001$0.00001
Lion15B128K$0.000001$0.000001
ZeroNo weightsNot applicable$0$0

Griffin

01

Deep reasoning · the hypothesis engine.

runs: Public or private cloud, on-prem or air-gapped · heavy reasoning budget · per-tenant inference isolation.
Architecture
  • 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
Training corpus
  • 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
Eval highlights

Published evaluations for Griffin will appear here once they are measured.

Eagle

02

Wide-angle triage · the surface scanner.

runs: CI + cloud · batched across the whole repo on every push.
Architecture
  • 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
Training corpus
  • 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
Eval highlights
94%
Top-5 taint path recall
87%
Triage precision
420 ms
p95 latency per package
70B
Parameters, dense

Lion

03

Inline · the commit-time gut check.

runs: IDE extension and CLI · served through Safeguard's API over TLS; the selected code is sent for analysis.
Architecture
  • 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
Training corpus
  • 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
Eval highlights
Small
Distilled from Griffin
Inline
Sink and secret checks
TLS
TLS to Safeguard's API
15B
Distilled parameters

Zero

04

No inference · the question, read in place.

runs: In process, on every deployment · zero tokens, and the prompt never leaves the platform.
Architecture
  • 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
Training corpus
  • 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
Eval highlights
0
Tokens consumed
0
Bytes sent to a provider
<1 ms
Prompt to query
100%
Deterministic and replayable
How a finding is routed

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.

01 · Triage score

Eagle assigns each candidate a complexity score from the call graph: depth, sanitiser ambiguity, cross-package edges, sink severity.

02 · Reasoning pass

Griffin runs the hypothesise → cite → disprove → patch trace. The trace ships with the finding so reviewers can audit how it was reached.

Inside the Griffin head

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.

Deployment shapes

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

Griffin, Eagle, Lion and Zero

Multi-tenant inference, fastest onboarding, per-tenant isolation at the prompt and KV cache layer. Best for teams trialling the lineup.

Dedicated cluster

Griffin, Eagle, Lion and Zero

Single-tenant inference on isolated VPC hardware. No cross-tenant traffic, deterministic latency, full SHA-pinned weight attestation.

VPC-isolated

Griffin, Eagle, Lion and Zero

Customer-controlled VPC, bring-your-own-key encryption, no cross-tenant traffic. Inference plane sits inside your network perimeter.

Sovereign / air-gapped

Griffin, Eagle, Lion and Zero

STQC-ready, no internet egress, on-prem GPU, full audit-log export. Suits regulated, classified, and sovereign deployments.

How they hand off

Commit to queue, one pipeline.

01Lion
Commit

Inline sink + sanitiser check on the selected code, through Safeguard's API.

02Eagle
Repo scan

Cross-package taint paths ranked across the codebase.

03Griffin
Path hypothesis

Deep reasoning posits an exploit chain + CWE class.

04Griffin
Adversarial disproof

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.

Cybersecurity-only training

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).
Provenance & safety

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.
Benchmarks at a glance

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.

StackFalse positive rateAdversarial prompt resistanceCross-package taint path recallLatency p95 (inline), not yet publishedRefusal rate on security Q&A
General-purpose LLM (zero-shot)62%41%18%1.8 s34%
Pure-LLM bug hunter (Mythos-class)54%63%37%2.4 s11%
Safeguard Lineup (Lion + Eagle + Griffin)6%98%94%Not published<1%
Numbers from Safeguard's internal eval suite. Methodology available under NDA.

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.