API Infrastructure.
Programmatic access to the full intelligence pipeline. Your existing systems call the API. The pipeline returns evidence-locked, scenario-complete, audit-sealed outputs. Your architecture stays intact.
Build or integrate. Same pipeline.
Whether you need a complete application or programmatic access to the intelligence layer, the underlying pipeline is identical. The difference is the interface.
Track 1: Build
Custom Intelligence Applications
We build the application. Your team operates it. The intelligence layer is embedded from day one. Every output is evidence-locked, scenario-complete, and audit-sealed.
Custom interface designed for your domain
Five-layer KRYOS reasoning pipeline
Calibrated to your regulatory context
Audit trails and compliance serialization
// Your custom application
const analysis = await kryos.analyze({
domain: "regulatory-compliance",
evidence: documentSet,
scenarios: ["base", "adverse"],
confidence_threshold: 0.92,
});
// Every output includes audit trail
console.log(analysis.audit_hash);
// → "sha256:7f3a..."Same Intelligence Core
Both tracks use the same five-layer pipeline. The difference is who writes the application code. The reasoning quality, governance standards, and audit guarantees are identical.
Core API reference.
Five endpoints cover the complete pipeline: submit evidence, retrieve audit trails, verify independently, inspect scenario branches, and trigger human escalation.
Submit evidence for full pipeline analysis. Returns scenario branches, conflict map, and synthesized output with confidence score.
Every response includes a confidence score.
The confidence score is a composite metric derived from evidence quality, scenario agreement, and conflict resolution completeness. It is not a probability. It is a measure of how well-supported the output is by the evidence.
Infrastructure-grade security.
Security is not a feature. It is a structural requirement. Every layer of the API infrastructure enforces authentication, encryption, and audit logging by default.
mTLS Authentication
Mutual TLS with certificate pinning. Every API call is authenticated at the transport layer before reaching the application.
Zero-Trust Network
No implicit trust between services. Every request is authenticated, authorized, and encrypted regardless of network position.
Encrypted at Rest
All data is encrypted at rest using AES-256. Encryption keys are managed through a dedicated key management service.
Rate-Limited & Throttled
Per-client rate limiting with configurable thresholds. Burst protection prevents resource exhaustion under load.
Audit-Sealed Responses
Every API response includes the audit hash for the analysis. Clients can verify the response was not modified in transit.
Webhook Callbacks
Asynchronous analysis results delivered via signed webhooks. Callback payloads include the audit hash for verification.
Three lines to your first analysis.
from kryos import Client
client = Client(api_key="your_key", endpoint="https://api.kryos.io")
# Submit evidence and receive full pipeline analysis
result = client.analyze(
evidence=[
{"source": "financial_report_q3.pdf", "type": "document"},
{"source": "market_data_feed", "type": "live_feed"},
{"source": "regulatory_filings", "type": "database"},
],
config={
"scenario_branches": ["base", "upside", "downside", "adversarial"],
"confidence_threshold": 0.75,
"escalation_enabled": True,
}
)
# Access the synthesized output
print(result.synthesis.conclusion) # Evidence-locked output
print(result.synthesis.confidence_score) # Composite confidence
print(result.audit_hash) # Verify independently
# Inspect individual scenario branches
for branch in result.branches:
print(f"{branch.type}: {branch.conclusion}")
print(f" Evidence: {len(branch.citations)} sources cited")
print(f" Confidence: {branch.confidence}")
# Retrieve the full audit trail
audit = client.get_audit(result.analysis_id)
print(f"Audit records: {len(audit.records)}")
print(f"Chain valid: {audit.verify()}")