Measured evidence infrastructure for AI

Better evidence.
Better answers.

Jylus turns live state, history, structured data and relationships into compact, proof-bound Context Packs before your model reasons.

Build with Jylus →See how it works
Your data stays yoursProof-bound contextUse any model
Jylus
JYLUS CONTEXT COMPILERRETRIEVE · RELATE · RANK · REDUCE
ADVERSARIAL MODEL EVALUATIONVIEW METHOD
100% strict accuracy
Strict accuracy100% across 528 frozen trials
Input reduction98.77% vs full context
Measured cost97.82% lower per query
Server-side evidence prep23.60× faster on average vs tuned RAG

Jylus finds what matters

One evidence API between your data and your model.

Keep the model focused on reasoning while Jylus resolves scope, retrieves relevant state and history, follows relationships, and prepares source-backed evidence.

Designed for live decisions

One data path. Three demanding workloads.

01

Models and agents

Build compact Context Packs from live state, history, relationships and semantic matches, with proof IDs and missing evidence kept explicit.

02

Security and observability

Ingest network, log and telemetry streams continuously and investigate them immediately.

03

Operational decisions

Compare current conditions with historical evidence while keeping scope, freshness and contradictions visible.

Measured model outcome

Same model. Same 528 questions.
Better evidence.

A frozen adversarial evaluation compared full context, BM25-only RAG and Jylus Context Packs under one strict evidence-bound answer contract.

FULL CONTEXT78.79%205,129 average model input · 7.58% hallucination trials
BM25-ONLY RAG76.14%8,128 average model input · 8.71% hallucination trials
JYLUS CONTEXT PACK100.00%2,532 average model input · 0.00% hallucination trials

528 unique adversarial questions and 1,584 completed evaluations using the same Gemini 3.1 Flash Lite model, settings and deterministic scorer across all three arms. Inspect the evaluation →

Frozen benchmark: context and cost528 questions · same model
100%strict accuracy across 528 frozen Jylus trials
98.77%less model input than full context
97.82%lower measured model cost per query
+21.21 pointsstrict accuracy versus full context
FULL CONTEXT205,129 tokens

Relevant evidence competes with unrelated history, noise and contradictions.

Same model · 78.79%
JYLUS CONTEXT PACK2,532 tokens

Compact, proof-bound evidence prepared for the question being answered.

Same model · 100.00%

The models did not change. The evidence supplied to them did. Public methodology describes the evaluation contract and measured outputs without disclosing proprietary compiler, ranking, fusion or tuning methods.

Evidence economics

Better evidence costs less, too.

Less model input reduced both measured cost and end-to-end latency in the frozen benchmark.

98.77%less model input
97.82%lower measured model cost/query
US$53,305 → US$1,160per 1M benchmark requests

Measured on the frozen Gemini 3.1 Flash Lite benchmark workload. Actual economics vary by model and workload.

Tuned hybrid RAG comparison18 questions · separate real-data cohort

Supporting real-data cohort

Tested against a tuned hybrid RAG stack on real operational data.

The competitor combined metadata and temporal filters, BM25, semantic embeddings, weighted fusion, recency ranking and model reranking.

JYLUS CONTEXT PACK100% accuracy100% evidence recall
TUNED HYBRID RAG83.33% accuracy75% evidence recall
Server-side evidence preparation23.60× faster on average7.42× faster at P95

18 blinded evaluation questions using sanitised real operational records. Jylus server processing measured 67.33 ms on average and 258.30 ms at P95, excluding the recorded client and Perth-to-Sydney network path. Client-observed preparation was 131.26 ms on average and 324.34 ms at P95. Supporting cohort, reported separately from the 528-question frozen benchmark. See the full result →

Context compiler measurements300 compiler-only runs · timing scope

Measured context compiler

74,414estimated source tokens→1,892final context-pack tokens

97.46% final-packet reduction · 21.04 ms P95 · 300 compiler-only runs

528 FROZEN JYLUS EVALUATIONS
100%strict evidence-bound accuracy
0%scored hallucination trials

100% evidence recall. Results apply to the defined benchmark.

Compiler timing excludes retrieval and model inference. Token counts use UTF-8 JSON characters divided by four; model tokenizers vary. Model input counts use provider-reported usage. Results apply to the defined workload, not every possible prompt or dataset. View methodology →

One operational surface

The full data path, visible at a glance.

Bring ingest, streaming, queries and incident response into one calm control plane without hiding the important details.

OverviewData streamsAPI keysBillingSupport
INGEST RATE18.42K/s↑ 12.4% today
API RESPONSE8.7msReference workload
DATA STORED6.4 GBof 10 GB
SYSTEM HEALTH100%Operational

Ingest throughput

Product preview

Ingest without friction

One event contract.
Two production paths.

Send authenticated HTTPS requests by default, or use a provisioned direct NATS JetStream connection for managed high-throughput deployments.

Your appJylus edgeRealtime store
⌁

Fast by default

Low-latency response paths and predictable stream handling, designed for AI workloads.

13.73 ms P95 in our 1M-event reference test
◎

Operated with guardrails

Usage caps, scoped keys, expiry, rate limits, audit events and incident visibility are built into the workflow.

Monthly spend capA$650

Predictive intelligence

Predict with evidence, not just the current signal.

Give prediction systems compact evidence that connects current conditions with relevant historical situations, temporal patterns, relationships and semantic matches.

Current stateContext CompilerPrediction modelHistorical matches · Temporal patterns · Relationships · Semantic similarity

Engineering proof

Run the 1M event demo.

Launch a governed one-second ingest run against the live Jylus engine. The workload is isolated, globally single-flight and rate-limited to protect customer traffic.

View test methodology

Measured results appear after the server-side run completes.

LIVE ENGINE RUNIDLE
Events accepted0
Accepted rate0/s
Publish ACK P50—
Publish ACK P95—
Publish ACK P99—
Pending at sample—
Failures0
Raw event bytes0 B
Measured by the isolated server-side publisher. No data-plane credentials are sent to the browser.

Built for developers

Send data once. Retrieve answer-ready evidence.

Use the authenticated HTTPS API or managed NATS JetStream for ingest, then request compact proof-bound context through the same developer surface.

01Create a scoped keyChoose only the permissions your service needs.
02Send with idempotencyRetry safely without duplicating accepted events.
03Watch it liveMeasure accepted rate, latency, errors, storage and stream activity.
Read developer docs
HTTPS event ingestcurl
curl https://api.jylus.ai/api/v1/events \
  -H "Authorization: Bearer $JYLUS_API_KEY" \
  -H "Idempotency-Key: evt_01K..." \
  -H "Content-Type: application/json" \
  -d '{
    "stream": "telemetry-production",
    "events": [{
      "id": "evt_01JYLUS9A2",
      "type": "model.completed",
      "occurred_at": "2026-07-25T09:42:00Z",
      "data": { "latency_ms": 8.7 }
    }]
  }'
202 ACCEPTED{"accepted":1,"rejected":0,"stream":"telemetry-production"}

Secure foundations

Security is part of the path, not a final checkbox.

Jylus uses server-side sessions, one-time key reveal, scoped credentials, CSRF protection, rate limits and a restrictive browser security policy.

✓ Argon2id password hashing✓ HttpOnly session cookies✓ HMAC-hashed API secrets✓ Idempotent event writes✓ Audit trail✓ Least-privilege scopes

Plans

Start free. Scale the workload.

Choose a plan for your event rate, concurrent queries and searchable history. Start with Developer to validate your workload, then choose the capacity you need.

Prices exclude GST and applicable taxes.

Developer

For API evaluation and a first proof of concept.

Free

No credit card required

Start free
  • 1,000 events/sec
  • 1 GB searchable storage
  • 7 days searchable history
  • 4 concurrent queries
  • HTTPS API access

Builder

For side projects and early production.

A$59/mo

Billed monthly

Choose Builder
  • 2,000 events/sec
  • 5 GB searchable storage
  • 14 days searchable history
  • 8 concurrent queries
  • Managed HTTPS + NATS
Production teams

Startup

For production applications, agent backends and log streams.

A$299/mo

Billed monthly

Choose Startup
  • 5,000 events/sec
  • 10 GB searchable storage
  • 30 days searchable history
  • 16 concurrent queries
  • Managed HTTPS + NATS

Scale

For high-volume telemetry and longer investigation history.

A$1,999/mo

Billed monthly

Choose Scale
  • 100,000 events/sec
  • 250 GB searchable storage
  • 365 days searchable history
  • 256 concurrent queries
  • Managed HTTPS + NATS

Enterprise

For custom workloads, procurement and service requirements.

Custom

Custom agreement

Talk to sales
  • Custom capacity and retention
  • Architecture review
  • Named support
  • Contract-defined service terms
Event rate
Events per second per workspace. API request limits are listed separately below.
Searchable storage
Data retained for querying, not a monthly ingest quota. Monthly ingest is not separately charged on self-service plans.
Searchable history
The plan's history window. Size the storage allowance for the data you want to keep searchable.
What happens when I reach an allowance?

Storage: Ingest continues. Developer shows an upgrade prompt; configured paid subscriptions meter additional retained storage when enabled. Check your subscription or order form for applicable charges.

Throughput and queries: The event-rate, API-request and concurrent-query limits still apply. Storage overage does not increase these limits.

Enterprise: Capacity, retention, support and service terms are agreed in your contract. A production SLA is available with redundant deployments; it is not implied by every plan.

Compare all plan limits Throughput, queries, storage and support
All plan limits. Enterprise capacity and service terms are agreed in your contract.
Included capacityDeveloperBuilderStartupScaleEnterprise
Event throughput1,000 events/sec/workspace2,000 events/sec/workspace5,000 events/sec/workspace100,000 events/sec/workspaceWorkload sized
API requests6,000/min/key8,000/min/key12,000/min/key60,000/min/keyWorkload sized
Concurrent queries4/workspace8/workspace16/workspace256/workspaceWorkload sized
Searchable history window7 days14 days30 days365 daysContract defined
Retained searchable storage1 GB included5 GB included10 GB included250 GB includedCustom capacity
Monthly ingestNot separately chargedNot separately chargedNot separately chargedNot separately chargedWorkload sized
Ingress profileStandard HTTPSManaged HTTPS + NATSManaged HTTPS + NATSManaged HTTPS + NATSContract-defined deployment
Maximum streamsNo fixed plan capNo fixed plan capNo fixed plan capNo fixed plan capWorkload sized
SupportCommunityCommunityEmailPriorityNamed support
OverageIngest continues; upgrade promptIngest continues; metered when enabledIngest continues; metered when enabledIngest continues; metered when enabledOrder form
Startup creditsEligible startups: up to A$10,000 platform credits for the first year.

Use credits to validate a production workload before capacity becomes the constraint.

Apply for credits
Early accessIntroductory pricing for launch partners.

Approved early-access teams receive a Stripe promotion code for their subscription.

Request early-access pricing

Use the measured path

Give your model better evidence.

Start free, send your own workload and inspect every proof ID.

Create your workspace →