Talon Platform

Confidential technical analysis. Post-quantum encrypted. Nothing leaks.

How It Works

Every use case follows the same protocol. The data type changes. The security model does not.

Your sensitive asset        Talon Enclave                    You
       |                         |                            |
       |--- PQC encrypt -------->|                            |
       |                         |--- Analyze (local LLM) ---|
       |                         |--- Check CVE databases  ---|
       |                         |--- Search patent records --|
       |                         |--- Score risk + quality  --|
       |                         |--- Sign report (ML-DSA) ---|
       |                         |--- Destroy raw data -------|
       |                         |                            |
       |<-- Signed report -------|                            |
       |                                                      |
       |--- Verify signature ---------------------------------|
    

Core Analyzers

Deployed Analysts

8 Production-Ready Agents — processing submissions now.

Janus

Receptionist

LIVE

Validates Bearer tokens using timing-safe HMAC comparison. Rejects unauthorized requests before they reach any endpoint.

“A PE firm submits code for diligence. Janus validates their API token in constant time — no timing side-channels.”

web_api/middleware/auth.py

Mars

Security Guard

LIVE

Adds 9 security headers (CSP, HSTS, X-Frame-Options, etc). Blocks payloads over 500MB.

“An attacker sends a 2GB payload to crash the server. Mars rejects it at the gate before it touches memory.”

web_api/middleware/security_headers.py

Caesar

Managing Director

LIVE

Dispatches all 9 analysts via asyncio.gather(). If one crashes, the others still deliver. Assembles the final report with risk scoring.

“A VC submits a target’s codebase. Caesar dispatches 9 parallel analysts and delivers a complete report in under 60 seconds.”

analysis/engine.py

Virgil

Report Writer

LIVE

Local Qwen2.5-Coder 7B on GPU via Ollama. Generates narrative analysis from raw findings. Zero data leaves the enclave.

“Raw semgrep output shows 47 findings. Virgil writes a human-readable narrative explaining the actual risk of each.”

analysis/llm_client.py

Brutus

Code Auditor

LIVE

Runs Semgrep with 1,000+ rules. Finds SQL injection, XSS, hardcoded secrets, insecure crypto, and 50+ vulnerability categories.

“A fintech’s payment processing code goes through Brutus. He finds a SQL injection in the transaction endpoint.”

analysis/semgrep_runner.py

Ceres

Supply Chain Analyst

LIVE

Parses requirements.txt and package.json. Cross-references every dependency against OSV.dev, NVD, and EPSS for known CVEs with exploit probability.

“A startup uses 147 npm packages. Ceres finds 23 have known CVEs, 3 with EPSS scores above 0.7 (actively exploited).”

analysis/supply_chain.py

Minerva

Patent Researcher

LIVE

Searches USPTO PatentsView API for overlapping patents. Identifies potential IP conflicts before investment.

“A deeptech company claims novel IP. Minerva finds 4 overlapping patents filed 2 years earlier by a competitor.”

analysis/patent_search.py

Vitruvius

Architecture Reviewer

LIVE

Measures cyclomatic complexity, code duplication, dependency depth, and test coverage. Produces a maturity score.

“A Series A target claims production-ready code. Vitruvius scores it 34/100 — high complexity, zero tests, copy-paste patterns.”

analysis/tech_benchmark.py

On the Roadmap

In Development

13 Planned Agents — under active development.

Mercury

Badge Printer

PLANNED

Assigns a UUID to every request. Threads it through logs, responses, and the audit trail.

“A client reports a failed submission. Mercury’s request ID traces it through every system in 30 seconds.”

web_api/middleware/request_id.py

Cato

Compliance Officer

PLANNED

Logs method, path, status, duration, and client IP for every request. Feeds Tacitus’s permanent record.

“A regulator asks who accessed what and when. Cato’s audit log has the answer for every API call ever made.”

web_api/middleware/audit_log.py

Cicero

Office Manager

PLANNED

Manages submission lifecycle from arrival through analysis to secure destruction. Handles interrupted submissions on restart.

“Server restarts mid-analysis. Cicero detects the interrupted submission and resumes it automatically.”

enclave/lifecycle.py

Seneca

Paper Researcher

PLANNED

Searches arXiv for related academic work. Identifies if the technology is genuinely novel or already published.

“A quantum computing startup claims breakthrough algorithms. Seneca finds the same approach published on arXiv in 2024.”

analysis/paper_researcher.py

Scipio

Infrastructure Scout

PLANNED

Extracts domains from submissions and checks DNS, WHOIS, and open ports. Determines if basic security hygiene exists.

“A SaaS company’s domain has no HTTPS, exposed admin panels, and a WHOIS registered last month. Scipio flags it all.”

analysis/infra_scout.py

Spartacus

Team Evaluator

PLANNED

Analyzes GitHub contributor data. Calculates bus factor, commit distribution, and identifies key-person risk.

“A startup has 8 ‘team members’ on their site. Spartacus finds 92% of commits come from one person. Bus factor: 1.”

analysis/team_evaluator.py

Pliny

Web Researcher

PLANNED

Crawls the company website. Extracts claims, product descriptions, team info, and cross-references against code findings.

“A company claims ‘enterprise-grade security.’ Pliny finds no security page, no SOC2 mention, and a WordPress blog from 2019.”

analysis/web_researcher.py

Livia

Company Analyst

PLANNED

Queries OpenCorporates and corporate registries. Verifies incorporation, jurisdiction, filing status, and corporate history.

“A founder claims 5 years of operations. Livia finds the company was incorporated 3 months ago in Delaware.”

analysis/company_analyst.py

Mnemosyne

Memory Keeper

PLANNED

Maintains cross-submission context via the knowledge graph. Enables pattern detection across multiple diligence runs.

“Three different startups use the same vulnerable open-source library. Mnemosyne connects the pattern across submissions.”

analysis/memory_keeper.py

Fortuna

Market Analyst

PLANNED

Reads Polymarket and Kalshi prediction market data. Adds crowd intelligence to focus area confidence scoring.

“Polymarket shows 73% probability that quantum computing reaches commercial viability by 2030. Fortuna weighs this into the thesis.”

analysis/prediction_markets.py

Vesta

Portfolio Monitor

PLANNED

Re-runs analysis on previously submitted companies. Detects new CVEs, changed infrastructure, or degraded code quality.

“Six months after investment, a portfolio company introduces 12 new critical CVEs. Vesta catches it before the next board meeting.”

analysis/portfolio_monitor.py

Clio

Filing Cabinet

PLANNED

Stores entities, relationships, and facts permanently in SQLite. Powers cross-submission queries.

“An LP asks ‘how many companies in the portfolio use Log4j?’ Clio queries the knowledge graph and returns the answer in seconds.”

storage/knowledge_graph.py

Tacitus

Logbook

PLANNED

Permanent, append-only record of every security event, API call, and system action.

“During an incident review, Tacitus shows exactly which submissions were accessed, by whom, and when — complete forensic trail.”

storage/audit.py

Planned agents are under active development. Deployment timeline depends on GPU capacity and model availability. All 8 deployed agents are production-ready and processing submissions.

Industries & Use Cases

The same encrypted pipeline. Different assets. Different questions.

Why Post-Quantum

Every submission is encrypted with ML-KEM-768 (NIST FIPS 203) combined with X25519. Every report is signed with ML-DSA-65 (NIST FIPS 204). This is not optional. It is the protocol.

Nation-states capture encrypted traffic today to decrypt when quantum computers mature. Source code submitted in 2026 with classical encryption could be readable by 2035. With Talon, it cannot. That is not a feature. It is the minimum acceptable standard for handling other people's intellectual property.

What Talon Does Not Do

• Does not retain your data. Raw submissions are cryptographically destroyed after analysis.
• Does not send data to third-party APIs. All LLM26 inference runs locally inside the enclave.
• Does not make decisions. Talon produces reports. Humans make investment, compliance, and security decisions.
• Does not require trust. Cryptographic attestation lets you verify the enclave state before submitting. The report signature lets you verify the output was not tampered with.

Request Access

Talon is currently in private deployment with SpringOwl Asset Management. Enterprise access is available for qualified organizations.

SpringOwl Asset Management | February 2026
This document is public and may be shared with attribution.