Auralis's whole pitch is that you watch the model reason instead of waiting for it to hand you a verdict. Each analysis streams four things to the canvas in sequence: intent, complexity, risk signals, and a final confidence score. That only feels good if every stage arrives quickly and consistently — and for a while, it didn't always.
Why we moved off OpenRouter
OpenRouter is a router, not an inference provider — it forwards each request to whichever upstream model is available, which is exactly the point of using it. But Auralis isn't one request per analysis, it's three sequential ones: parse intent and complexity, extract risk vectors, then calibrate confidence against both. Each stage waits on the one before it, so any latency variance in a single stage doesn't just slow that stage down, it compounds across the whole pipeline.
Most of the time this was fine. Under load, or when a request landed on a slower upstream, it wasn't — a three-stage analysis could swing from feeling instant to feeling stuck, with no consistent pattern a user could learn to expect. For a product built around watching the reasoning happen, inconsistent pacing undermines the entire premise.
Groq runs llama-3.3-70b-versatile directly on its own LPU inference hardware. One provider, one inference path, nothing being routed underneath us mid-request. That trade — losing OpenRouter's model flexibility in exchange for one fast, predictable path — was the right one for a pipeline this latency-sensitive.
The three-stage pipeline, now on Groq
The pipeline itself didn't change — the same three reasoning stages still run in the same order, gated by the same regex pre-scan ahead of them and the same sandbox behind them. What changed is what they run on.
Intent & Complexity Parsing
Classifies what the submitted code is trying to do and scores its structural complexity — the baseline the later stages reason against.
Risk Vector Extraction
Scans for concrete risk signals — shell injection, filesystem escapes, network abuse, unsafe deserialization — and assigns each a severity.
Confidence Calibration
Weighs the first two stages against the pre-scan and produces the calibrated score that drives the Safe Mode decision.
All three still stream token-by-token to the analysis canvas — that part of the experience didn't need to change, just the transport underneath it.
Hardening the edge function
The migration window was also the right time to fix something that had been a quiet sharp edge for a while: the analysis edge function had no firm payload size ceiling. An unusually large file would queue up, eventually hit a timeout, and surface to the user as a flat "Analysis failed" — accurate, but useless.
The function now validates payload size before doing anything else. Oversized submissions are rejected instantly with a clear reason, instead of queueing toward a timeout. We also added per-user rate limiting on top of it — Auralis is still in beta, and one misbehaving client shouldn't be able to crowd out everyone else's share of the Groq quota.
// auralis edge function — request guard (simplified)
if (bytesIn > MAX_PAYLOAD_BYTES) {
return json(413, {
error: "payload_too_large",
message: "File exceeds the analysis size limit.",
});
}
if (await isRateLimited(userId)) {
return json(429, { error: "rate_limited" });
}
const result = await runPipeline(code, { model: "llama-3.3-70b-versatile" });What's next
- Expanding risk-vector coverage for Go, Rust, and Java — currently mid-review
- Re-tuning Safe Mode thresholds (Strict / Balanced / Permissive) against real beta usage instead of launch-day heuristics
- Session diffing in Cybase — compare two analyses of the same file across time
- A second model as a cross-check on the confidence calibration stage, in the same spirit as Cyanix's Axion ensemble
Try Auralis →
Free beta access. No credit card required. Sign in with GitHub or Google.
Open Auralis