GUT stands for Guided Unconscious Thinking — the fast, instinctive judgment layer (System 1) that acts before slow reasoning is needed. GUT is a fine-tuned Laya, the open 421M-parameter decision model: our cloud engine's judgment, distilled to run entirely on your hardware. Classify anything. Navigate real websites. Keep every byte private.
Real footage — no mockups. GUT steering a live browser through the ASIC business-name registration workflow: every option it scanned, the candidates it weighed, the choice it made, and the training row it saved. It stops at the login boundary by design.
Classification with general models is slow, hallucination-prone and hard to categorise. LLM agents struggle to navigate websites autonomously. And private data cannot be handed to an AI provider at all.
Seconds per verdict. Confident hallucinations. A bill for every call. And a taxonomy you cannot control.
LLM agents misclick, loop and lose the plot — autonomous website navigation mostly fails in practice.
Data you cannot send to a provider never gets graded. Private stays useless — everywhere else.
The fleet teaches while it works. Three moves, repeated forever.
Every verdict our systems make — a grade, a verification, a route, a click — is logged as a training row with its full probability distribution. Soft labels keep the teacher's hedging.
RLCD reinforcement learning scored by proper statistical rules, then a hard gate on held-out data: match the teacher ≥0.85, keep calibration error ≤0.10. Pass or it never ships.
A passing checkpoint registers behind POST /v1/systemone — the same wire protocol as the cloud. One URL flips any app from cloud to local.
One architecture, ten specialists — each served per-domain behind one local endpoint. The systems they power are cross-linked below.
| Domain | What it decides | Where it's used |
|---|---|---|
| monitor-triage | severity · wake-the-owner · cause | qalarc monitor |
| osint-grading | verified / likely / weak / junk | OSINT hub |
| gmux-routing | complexity · risk · reasoning · context → tier | gmux agent fleetgmux.ai |
| rfai-feed | RF transmission class + operator interest | RFAI monitor |
| rfai-intent | radio call intent + urgency | RFAI monitor |
| geo-attribution | AI-engine citation correctness · escalate | GEO pipeline |
| geo-audit-triage | finding priority p0-p2 · fix-now | universal GEO analyzer |
| seo-grading | quality · intent · cannibalisation · change significance | universal GEO analyzer |
| compliance-marks | keep · canonical · on-theme | doof.ing library |
| chanalyse | thread topic (71) + content safety | chanalyse monitor4chan analytics |
| browser-ops | operation + target per click · completion | autonomous navigation — filmed above |
What the 80 seconds cannot show.
GUT serves the exact same API as the TypeSafe Jev cloud engine — typed questions (choice / score / noul) in, calibrated probabilities out. The X-Laya-Domain header picks the specialist. One URL flips cloud to local.
Every checkpoint must agree with its teacher on held-out data AND keep its probabilities honest. Nine runs are in the audit trail; none has passed yet. The best calibration so far: ECE 0.07. Nothing uncalibrated ever serves.
Every training row comes from live qalarc operations — real monitors, real scans, real browser walks. Soft probability labels throughout. This dataset exists nowhere else and grows every day the fleet runs.
Task-directed navigation stops at credential walls by design. In the film above, GUT walked the ASIC registration flow and halted exactly at the login — the machine prepares every step, the human signs.
GUT is the reflex: pattern-matched verdicts in ~20ms. Novel situations escalate to big reasoning models or humans. Browsers get instincts; judgment stays where it belongs.
Every cloud decision the fleet makes becomes training data for the local model that replaces it. The more the system runs, the less it needs the cloud.
Modest by design — the whole point is running where your data lives.
| Use | Minimum | Comfortable |
|---|---|---|
| Serve a checkpoint | 8 GB RAM · any x86/ARM CPU (~2.5 s/decision) | Any 4 GB GPU (17-23 ms/decision) |
| Fine-tune small domains | 16 GB RAM workstation, CPU-only (~1 h per 1k rows) | One 16 GB GPU (T4 class) — minutes |
| No GPU at all | The pipeline pushes itself to Kaggle as a ready kernel — free 2×T4 sessions do the training | |
| Software | Python 3.11+, PyTorch (CPU or CUDA), the laya package (Apache-2.0), Playwright for browser capture | |
| Operating system | Linux tested (Ubuntu / Arch); macOS + Windows serve fine on PyTorch CPU/CUDA | |
The pipeline ships as an app. If your systems make recurring decisions — grades, routes, labels, clicks — you can distill them into your own GUT in three moves.
Point the collector at your workflow. Every verdict is logged as a training row with its full probability distribution. Works with any System One-compatible decider, human labels, or plain automation logs.
One command runs the RLCD loop and the calibration gate on held-out data. Workstation or free Kaggle GPUs. You receive a gate table — pass or fail — every single time.
A passing checkpoint registers into the local endpoint. Your apps talk to 127.0.0.1:8798 with the cloud's exact API — one URL flips between them. Nothing leaves your machine.
PolyForm Noncommercial 1.0.0 for code · CC BY-NC 4.0 for datasets and weights. Commercial licensing via qalarc — we make it easy.