How an answer actually gets made
Agentlytics is a workspace where you hand over messy files and get back verifiable answers - not a chatbot that free-associates numbers at you. Here's the full trip a file takes, from the moment it lands to the moment a claim carries a citation.
Your file lands somewhere private
Every file you drop in goes straight into your own workspace - sealed off from every other workspace before a single byte of it is read. From there it's queued, so a 400MB export never blocks the rest of the app for you or anyone else.
Ingestion sorts out what it's actually looking at
A spreadsheet and a scanned contract don't need the same treatment, so they don't get it. Tabular files are parsed and normalized into a fast, queryable store. Documents are parsed, chunked, and indexed for semantic search. Nothing gets flattened into generic text just to make the pipeline simpler.
Your question gets split up and handed off
Ask something and it's broken into pieces of work, each handed to a specialized investigation agent running in its own private context. One agent's dead ends never leak into another's reasoning - it only ever sees the findings it actually needs. That isolation is what keeps one line of inquiry from polluting another.
Agents don't answer from memory
Every number or fact an agent reports comes from calling a tool that runs a real computation against your actual files - a real query, a real retrieval, never a guess dressed up as one. The model reasons over what the tool hands back; it doesn't get to invent the result.
Custom analysis runs in a box it can't escape
When an investigation calls for something beyond a standard lookup, that generated code runs inside an isolated sandbox with no access to the host system or any other workspace. Whatever it does, it does inside a disposable environment that gets thrown away right after.
A worker picks up the job in the background
Investigations don't run inside the same process that's serving your requests. Each one gets handed off to a dedicated worker that pulls jobs off a queue, runs them in the background, and keeps going even if you close the tab or your connection drops.
Redis is the nervous system underneath it all
It's the piece connecting parts that never talk to each other directly - holding the queue the worker pulls jobs from, and carrying the live progress events the worker publishes while an investigation runs. The API, the worker, and your browser all stay in sync through it.
You watch it happen, live
Your browser doesn't poll for updates - it opens a live stream that subscribes to those Redis events and renders each step as it happens. Refresh mid-investigation and everything that already ran replays first, then the live feed picks back up. A dropped connection never costs you your place.
An answer you can actually check
When the investigation wraps up, the findings get assembled into a final answer - and every claim in it carries a reference back to the exact file, row, or page it came from, plus a chart or report if one was useful along the way. That's the whole point: something you can verify, not just believe.
See it run on your own files
The fastest way to understand the pipeline is to watch it investigate something you actually uploaded.