Full context
- Average complete model input
- 205,129 tokens
- Published model cost per query
- US$0.053305
- Strict answer accuracy
- 78.79%
- Scored hallucination trials
- 7.58%
Real-time data platform for applications and AI
Store and search live data.
Build apps and AI.
Ingest records, search them, track changes and connect related information in one platform. Use the results in your application, or prepare compact, source-backed context for your AI.
Consolidate the data services behind your application and reduce the context sent to your AI.
Your data stays yoursYou control retentionStart free · no card
JYLUS DATA PLATFORMINGEST · RETAIN · QUERY · BUILD
ORDER-SUPPORT APPLICATIONEXPLORE THE DATA →
SOURCE RECORDS
Order createdShipment reported delayedLater correction: in transitSynthetic scenario · inspect every observation
YOUR APPLICATIONRecords and queries
State · history · relationshipsAI evidence when you need itRetainYour records your retention policy
QueryState and history through documented APIs
BuildApps and AI from the same data
Open a quickstart →An application workload, end to end
Run the data behind an order-support application.
An order is created. Its shipment is reported delayed. A later correction changes that status. Follow the same records through your application's data work and into AI context.
Records
Four observations are stored and read back: an order is created, a delay is reported, a correction arrives and a customer opens a ticket.
Run the demonstration to see real responses here. No result is precomputed or substituted.
Separate recorded comparison · no model call
Compare model input and cost.
The walkthrough estimates evidence size. This separate comparison shows the published same-model benchmark: complete model input, cost per query and scored answer quality. It does not use your sample or rerun a model.
Frozen benchmark: 528 questions across four data domains
Same Gemini 3.1 Flash Lite model and settings on both paths. Average per query; different data from the four-record walkthrough.
Jylus Context Pack
- Average complete model input
- 2,532 tokens
- Published model cost per query
- US$0.001160
- Strict answer accuracy
- 100.00% observed
- Scored hallucination trials
- 0.00%
The published 98.77% input reduction and 97.82% model-cost reduction apply to this defined benchmark. They are not savings measured in your trial. A small Context Pack can be larger than its source records.
What was measured, and how were answers checked?
Model input is the complete input used by the model, including the question, instructions and supplied evidence, rather than the walkthrough's source-size estimate. The benchmark compares full context and Jylus evidence using the same model settings and deterministic scorer.
The strict answer gate checks the expected answer and required source evidence. The published contract retains raw answers, provider request IDs, timings, hashes and checkpoints. Acceptance requires zero missing pairs, duplicate cells, execution errors or malformed response hashes.
Cost is the published per-query model cost calculated from provider-reported usage at the benchmark's frozen standard rates. This is not an invoice or a current quote. Your bill also depends on output, caching, rates and usage; Jylus subscriptions and other application costs are separate.
528/528 Jylus answers passed in this cohort. That is an observed result, not a universal accuracy guarantee. The evaluation has not been independently reproduced.
Keep production traffic where it is while you evaluate
Test one workload on Jylus.
Use a free workspace to run a small copy alongside your existing system. Compare the same records and operations before deciding what to move.
Records and queries
Ingest an order timeline, verify the source IDs and query a single order’s records.
Open records quickstart →Search and investigation
Search a delay, compare observations over time and follow explicit order and shipment links.
Open search quickstart →AI retrieval and evidence
Prepare source-backed context. Inspect readiness and proof IDs before sending it to your chosen model.
Open AI quickstart →Know the operating boundaries before you switch.
- Data behaviour
- JSON events over HTTPS, source-ID and time queries, bounded history and analysis. The records quickstart uses those ID/time filters; verify every other required business-field filter on your workload. Acceptance is separate from query readiness: verify the receipt and read back IDs. Corrections are new linked events. This is not a claim of multi-record ACID transactions or existing database-driver compatibility.
- Retention
- Choose expiry or no expiry in workspace settings. Expiry removes eligible records; it is not just a search filter. Keep an independent source copy for your evaluation.
- Access controls
- Workspace isolation, scoped read/write API keys, key revocation, team roles and account MFA. Keep secret keys on your backend. Security details.
- Export and recovery
- Read source records through bounded query windows and save them in your own archive. The quickstart saves a receipt and responses locally. A one-click full-database export, customer point-in-time restore, three-machine deployment or contracted recovery objectives are not included promises; agree requirements with support before migrating.
- Limits and cost
- Free Developer includes 1 GB. At the storage cap, new ingest pauses; retained data is not deleted and permitted reads continue. Paid expansion needs an available billing option, your approved rate and spending cap. Buying storage preserves throughput and query limits. Compare plans.
- Support
- Use support@jylus.ai for evaluation questions. Confirm plan support, SLA, regional capacity, recovery and migration arrangements before moving critical traffic. API limits and retry behaviour.
Start with a specific application path
What can Jylus replace?
Choose a workload to evaluate. See the current architecture, the Jylus path, what can disappear and what still belongs in your stack.
Chroma Cloud
Assess and copy a Chroma Cloud workload
Use Jylus Migrate to discover collections, assess compatibility and storage, then approve a verified record-copy evaluation while Chroma Cloud keeps serving.
Explore this replacement evaluation →MongoDB
Evaluate an order-event read workload
Move the records and reads behind a support screen: order observations, a bounded timeline and exact field queries.
Explore this replacement evaluation →Elasticsearch
Evaluate support-event search and investigation
Search shipment reports, filter by order and inspect the observations and linked records behind a support incident.
Explore this replacement evaluation →Pinecone
Evaluate retrieval plus order-state evidence
Use one order-support workload to test retrieval, source lookup, corrected state and the context an AI agent receives.
Explore this replacement evaluation →Databricks
Serve live order history to your application
Test the order-history API used by your support application, alongside your existing analytics system.
Explore this replacement evaluation →Prefer to keep your stack? Jylus can also work alongside it as an evidence API for your existing application and model. Follow the additive integration guide →
Also available alongside your existing stack
Add evidence preparation to an application you already run.
Keep the model focused on reasoning while Jylus resolves scope, retrieves relevant state and history, follows relationships, and prepares source-backed evidence.
For applications that also need AI evidence
Beyond conventional RAG
Relevant content is a starting point. Inspect current and historical state, transitions, relationships, contradictions, missing evidence and source proof IDs before your model reasons.
Keep your existing data stack and model if that suits your workload. Use Jylus to prepare evidence alongside them, or evaluate the wider data platform first.
Explore the eight evidence capabilities
Semantic retrieval
Retrieve relevant records for a question and inspect the returned sources. Measure relevance against your own expected results.
Structured filtering
Scope queries to an order, customer or other supported fields. Check that unrelated records stay outside the result.
As-of state resolution
Compare the latest observation with an earlier source observation. The order-support demonstration shows the delay before its correction. Knowledge-time evaluations use the server-recorded arrival time.
State transitions
Inspect the timeline and the source records behind a status change. Keep event time and observation time explicit when evaluating late updates.
Contradiction detection
Inspect conflicts reported in the Context Pack rather than asking a model to silently choose a value. Verify the reported sources and scope.
Missing-evidence reporting
Check completeness, missing evidence and decision readiness. A successful HTTP response alone does not mean there is enough evidence to answer.
Proof IDs per fact
Follow retained facts back to their source proof IDs. The AI quickstart checks the proof set against the records it submitted.
Model-independent evidence
Inspect the returned JSON before passing it to your chosen model. Jylus prepares the evidence; model-provider calls and charges remain separate.
These are evaluation points for Jylus, not a blanket comparison with every search or RAG implementation. Run the AI evidence quickstart →
Designed for live decisions
One data path. Three demanding workloads.
Models and agents
Build compact Context Packs from live state, history, relationships and semantic matches, with proof IDs and missing evidence kept explicit.
Security and observability
Ingest network, log and telemetry streams continuously and investigate them immediately.
Operational decisions
Compare current conditions with historical evidence while keeping scope, freshness and contradictions visible.
Measured evidence preparation
Better evidence. Measured outcomes.
Observed results on defined workloads. The accuracy and input reduction use the frozen operational benchmark; the tuned-RAG speed comparison uses a separate operational cohort.
View methodologyOne operational surface
The full data path, visible at a glance.
Follow ingestion, inspect retained records, query the data and prepare evidence when your workload calls for it.
A real portal recording with synthetic checkout records. Playback is not a latency benchmark.
Try your own dataRead transcript
- The result. Compact evidence with inspectable proof.
- Ingest & verify. Accepted is not the same as searchable.
- Explore records. Original records, scope and source time.
- View metrics. Measured activity, latency and retained records.
- Get a Context Pack. Evidence your application receives.
- Follow the proof. Inspect the source. Copy the API request.
The demo shows a checkout release, database connection pool timeouts and a degraded service. The question asks what changed and which records support it. The returned Context Pack and its proof IDs are inspected in the portal. The copied API request keeps the test scope and uses a placeholder read key.
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 testOperated 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 state→Context Compiler→Prediction 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.
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
Built for developers
Ingest records. Query them. Build your application.
Use the authenticated HTTPS API for ingest, exact queries, search and analysis. Start with a working workload quickstart; add Context Packs when your application needs AI evidence.
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.
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 your throughput, query capacity and included storage. You control how long records are retained.
Included in every plan
- Native Context Packs
- State and relationship analysis
- Source proof IDs
- Customer-controlled retention
Store and query your data, with AI context when you need it. Model-provider charges are separate.
Developer
Explore the API and build your first working integration.
Free
No card required
1 GB included1 GB cap. New ingest pauses when full. Upgrade for more storage.
Start free- 1,000 events/sec
- 4 concurrent queries
- Community support
Choose when records expire, or keep them until you delete them.
Builder
For side projects and early production workloads.
A$59/mo
Base subscription billed monthly
5 GB includedA$3.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval.
Choose Builder- 2,000 events/sec
- 8 concurrent queries
- Community support
Choose when records expire, or keep them until you delete them.
Startup
For production teams that need more throughput, query capacity and email support.
A$299/mo
Base subscription billed monthly
10 GB includedA$2.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval.
Choose Startup- 5,000 events/sec
- 16 concurrent queries
- Email support
Choose when records expire, or keep them until you delete them.
Scale
For high-volume production and larger engineering teams.
A$1,999/mo
Base subscription billed monthly
250 GB includedA$1.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval.
Choose Scale- 100,000 events/sec
- 256 concurrent queries
- Priority support
Choose when records expire, or keep them until you delete them.
Enterprise
For custom deployments, procurement and service requirements.
Custom
Custom base subscription
Custom storageA$0.50–A$0.80 / extra GB-month. Your exact rate is quoted before activation. You approve the quoted rate and monthly spending cap before expansion activates.
Talk to sales- Workload-sized throughput
- Contract-defined query capacity
- Named support
Choose when records expire, or keep them until you delete them.
Plan your bill
Monthly cost calculator
Storage expansion preserves your plan’s throughput and query limits.
- Base subscription per month
- A$299.00
- Included storage
- 10 GB
- Additional storage 0 GB average
- A$0.00
- Estimated monthly total
- A$299.00
Actual additional-storage billing is time-weighted from retained storage above your allowance. Approve the displayed rate and monthly spending cap before expansion activates. Annual discounts apply to the base subscription; storage is billed monthly. The estimate assumes this average balance throughout the month; fluctuations can change actual extra-storage usage. Storage uses 1 GB = 1,073,741,824 bytes. Estimates exclude tax and model-provider charges.
Start with Startup →Context Pack limits and proof details
- Analyze requests
- Use the plan’s API rate limit and query concurrency. No separate monthly Context Pack allowance.
- Context budgets
- 256–100,000 estimated output tokens per request; 4,000 default. This is a compiler output budget, not purchased model tokens.
- Relationship analysis
- Up to 16 fields and 1,000 returned relationships per request, within the governed scan.
- Proof and audit
- Context Packs include source proof IDs. Source availability follows customer-controlled retention. Sampled compiler audit traces and OpenTelemetry export are operator-configured.
Storage caps, spending limits and retention
Free: Developer includes 1 GB with no card required. When full, new ingest pauses. Reaching the cap does not delete existing records or block permitted reads; your retention policy still applies.
Paid storage: When available for your selected billing option, approve the rate and a monthly spending cap before expanding. Storage grows within that cap. New ingest pauses when capacity is reached; the cap does not increase automatically. Your throughput and concurrent-query limits stay the same.
Retention: Choose when records expire, or keep them until you delete them. For example, with 30-day retention, records expire once their retention timestamp passes the rolling cutoff; newer records remain. No expiry keeps records until deletion. Changing retention cannot restore deleted records.
Compare all plan limits Throughput, queries, storage and support
Scroll across to compare every plan. The first column stays visible.
| Included capacity | Developer | Builder | Startup | Scale | Enterprise |
|---|---|---|---|---|---|
| Event throughput | 1,000 events/sec/workspace | 2,000 events/sec/workspace | 5,000 events/sec/workspace | 100,000 events/sec/workspace | Workload sized |
| API requests | 6,000/min/key | 8,000/min/key | 12,000/min/key | 60,000/min/key | Workload sized |
| Concurrent queries | 4/workspace | 8/workspace | 16/workspace | 256/workspace | Workload sized |
| Retention | Your choice, including no expiry | Your choice, including no expiry | Your choice, including no expiry | Your choice, including no expiry | Your choice, including no expiry |
| Retained searchable storage | 1 GB included | 5 GB included | 10 GB included | 250 GB included | Custom capacity |
| Monthly ingest | Not separately charged | Not separately charged | Not separately charged | Not separately charged | Workload sized |
| Ingress profile | Standard HTTPS | Managed HTTPS + NATS | Managed HTTPS + NATS | Managed HTTPS + NATS | Contract-defined deployment |
| Maximum streams | No fixed plan cap | No fixed plan cap | No fixed plan cap | No fixed plan cap | Workload sized |
| Support | Community | Community | Priority | Named support | |
| Overage | 1 GB cap. New ingest pauses when full. Upgrade for more storage. | A$3.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval. | A$2.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval. | A$1.00 / extra GB-month. Activation is pending for this billing option. New ingest pauses at included capacity; extra charges require your rate and spending-cap approval. | A$0.50–A$0.80 / extra GB-month. Your exact rate is quoted before activation. You approve the quoted rate and monthly spending cap before expansion activates. |
Prove one application workload
See what you could build on Jylus.
Evaluate records, search or AI evidence alongside your existing system.