# Jylus

> Jylus is a measured evidence infrastructure platform that ingests live data, resolves state and relationships, detects contradictions, and delivers source-backed context packs to AI models and agents.

Jylus is a governed evidence and state layer for enterprise AI, built by Jylus Systems Pty Ltd in Perth, Australia. It sits between your live data sources and your AI model, compiling proof-bound Context Packs that include current state, historical transitions, relationship graphs, and explicit missing-evidence signals — so models reason over verified facts rather than stale or ambiguous retrieval results.

## What It Is

Jylus is an evidence preparation API — not a vector database, not a RAG wrapper, and not an answer model. It accepts arbitrary JSON events through a tenant-scoped HTTPS API or a managed NATS JetStream connection, then exposes four production-path operations: ingest, search, structured query, and a hybrid `/analyze` endpoint that compiles token-budgeted Context Packs with source proof IDs. The core differentiator is that every retained claim in a Context Pack carries a proof ID traceable back to the original source record, and the system explicitly reports when evidence is missing or contradictory rather than silently omitting it.

## How the Evidence Pipeline Works

The Jylus Context Compiler follows a four-step path — Retrieve, Relate, Rank, Reduce — before handing evidence to any model:

- **Retrieve**: Combines structured filtering, lexical search, and semantic vector retrieval in a single `/analyze` request.
- **Relate**: Follows entity relationships up to 16 fields deep and returns up to 1,000 relationship hops per request.
- **Rank**: Scores evidence by relevance, freshness, and source role (e.g., `status`, `transition`).
- **Reduce**: Compiles the result into a token-budgeted Context Pack (256–100,000 estimated tokens, defaulting to 4,000) with proof metadata and completeness signals.

The API returns two explicit completeness flags — top-level `complete` for the governed scan and `context.proof.complete` for the compiled evidence — so downstream agents know whether absence of evidence is a real signal or a scope limitation.

## Architecture and Ingest Infrastructure

Jylus accepts events via authenticated HTTPS POST to `/api/v1/events` with idempotent writes (24-hour reservation window). Builder and higher plans can use a provisioned managed NATS JetStream connection for sustained high-throughput ingest. The platform also ships downloadable Docker and OpenTelemetry collectors that buffer through outages and deliver through the same tenant-scoped HTTPS path. The public data region is Sydney, Australia. The platform publishes a canonical OpenAPI 3.1 specification, a Postman collection, and minimal Node.js and Python client examples.

## Target Workloads

Jylus is designed for three demanding operational scenarios:

- **AI models and agents**: Compact Context Packs from live state, history, relationships, and semantic matches, with proof IDs and missing-evidence flags kept explicit.
- **Security and observability**: Continuous ingest of network, log, and telemetry streams with immediate investigation capability.
- **Operational decisions**: Comparing current conditions with historical evidence while keeping scope, freshness, and contradictions visible.

The platform also supports prediction systems by connecting current conditions with relevant historical situations, temporal patterns, and semantic similarity.

## Measured Performance Claims

Jylus publishes benchmark results on a frozen operational cohort. According to the vendor's own methodology page, the platform observed 528/528 strict accuracy on a defined workload, 98.77% reduction in model input tokens compared to passing raw source data, and 23.6× faster evidence preparation than a tuned RAG baseline. The vendor explicitly notes these are measured results for those specific workloads, not a guarantee of universal accuracy.

## Security Model

Security is built into the ingest path rather than added as a layer. The platform uses Argon2id password hashing, HttpOnly session cookies, HMAC-hashed API secrets, idempotent event writes, an audit trail, and least-privilege scoped API keys. Separate read and write keys are recommended for different workload types, and workspace keys are explicitly prohibited from browser or client-side code.

## Features
- Proof-bound Context Packs with source proof IDs
- Live state and historical state resolution
- Relationship graph traversal (up to 16 fields, 1,000 relationships)
- Contradiction detection and missing-evidence reporting
- Hybrid /analyze endpoint combining structured, lexical, and semantic retrieval
- Managed NATS JetStream for high-throughput ingest
- HTTPS event ingest with idempotent writes
- Docker logs collector
- OpenTelemetry collector
- Token-budgeted evidence compilation (256–100,000 tokens)
- Scoped API keys with least-privilege permissions
- Audit trail and compiler audit traces
- OpenTelemetry export support
- Interactive API reference and OpenAPI 3.1 spec
- Postman collection and client examples (Node.js, Python)
- Usage caps, rate limits, and spend caps
- Real-time ingest dashboard with latency and throughput metrics

## Integrations
OpenTelemetry (OTLP), Docker, NATS JetStream, Postman, Any LLM or AI model (model-independent), Node.js, Python

## Platforms
API, CLI, WEB

## Pricing
Freemium — Free tier available with paid upgrades

## Links
- Website: https://jylus.ai
- Documentation: https://jylus.ai/docs
- EveryDev.ai: https://www.everydev.ai/tools/jylus