An on-premise operating system for the whole deal — and the relay of thirteen people who run it, each with an iPad. Ten stages, thirteen agents, a consensus council for the calls that must be right — and every action logged, timed and measured, captured by on-prem voice and proof, even offline. Nothing leaves your box.
A program record per deal (a unique Customer ID, like a patient chart), advanced through a state machine with a hard compliance gate. Every stage has a live agent; the horizontal stepper shows exactly where each deal sits.
Deterministic where the answer is facts (logistics, entitlements, order); a heterogeneous on-premise model council where the answer is judgment. Agents propose; the human decides.
Full council rates allocation, lead time and single-source exposure; names qualified alternates.
The cheapest landed path that still holds the committed window — with the swap delta.
Council screens end-use, ECCN and destination. A lone concern is flagged, never trusted. No clear, no order.
Line items, tier terms and the entitlement approval gates — a bookable order.
Pack plan, lane, mode, ETA and freight — with the oversized/high-value risks called out.
Onsite dispatch, waive-or-charge install SLA and warranty registration, by tier.
A config-aware rack → burn-in → acceptance runbook with real acceptance criteria.
Training by criticality + tier; monitoring, metering and a path to consumption rental.
3-yr TCO & payback; council-backed party triage; auditable outbound redaction.
Hours and dollars given back — computed live from the attributed activity log against transparent baselines, per junction and per deal.
For the calls that must be right — compliance, sourcing, factual answers — a heterogeneous panel of different-family local models votes and an adjudicator reconciles. Agreement is kept; a single-model claim is flagged as a likely hallucination. Accuracy over approximation.
A deal isn't one person clicking through ten stages. It's a relay — sourcing, compliance, logistics, an integration tech, a carrier, a field installer, the customer who signs for it, finance, ops. The accelerator gives every one of them their own iPad surface, and turns each action into an attributed, timestamped, measured record. On-premise, zero egress, even offline.
Every persona opens to their own queue. Advancing a deal passes the baton into the next roles' worklists automatically, with SLA clocks; a live "your turn" bell pings when work lands.
Open a task and just say it — "received 6 of 8, one crate damaged, burn-in running." Transcribed on-box by native MLX Whisper (~200ms warm), mapped to the form's fields by a local model. Or snap a packing slip.
Photo, signature, barcode/serial scan, a device geo-stamp, and draw-on-the-photo annotation to circle the damage — every capture attributed to a real person, role and device.
Captures queue on a dead dock and sync idempotently on reconnect. Then it's measured — cycle time, SLA adherence and throughput, per person and per role.
The driver and the customer have no account. An internal coordinator sends a scoped, expiring, one-time link; they confirm the delivery with a signature on their own phone, and it's audited like everything else. And voice is transcribed on Apple silicon, on-premise — a native MLX-Whisper service with a browser fallback — so a spoken field note never touches a cloud.
The accelerator doesn't just run the deal inside your walls — it brings the outside world into the deal. Weather, shipments and market volatility, pulled in through one governed egress boundary that keeps customer data on your box. The trust story doesn't weaken; it's the thing that makes world-awareness safe.
A drawer of AI utilities — handwriting & document OCR, label/barcode generation, translation, drafting — behind a router that keeps sensitive work (deal data, prices, competitors) on the box, and only escalates a deep, non-sensitive task to a frontier model via the local Claude bridge, redacted first.
One audited exit for anything that leaves the box. Public queries go out — weather, shipment, market — customer data never does. Every call is scrubbed, rate-limited and ledgered, with per-connector on/off in the Trust Center.
The fulfillment lane reads real destination weather and flags delivery risk before the carrier does — “thunderstorm at Atlanta · at-risk · ETA may slip ~3 days” — read from a local world-feed store, so the iPad stays fast and offline-safe.
The forward price band widens and shifts with live market volatility (prediction-market signals, GPU spot, freight), then recommends lock / hedge / re-quote with the dollars at stake and the Deal-Desk guardrail — and prices a weather slip in dollars.
A real interactive map — on-prem geography, zero tile egress — with the weather overlay on the lane. And a big-screen war-room: pipeline value, at-risk shipments, the world-feed and the egress ledger. A wall a sales leader can watch.
Share a scoped, login-less link and the customer watches their order live — status, milestones, the shipment map, warranty — with no pricing exposed. And the deal state machine emits signed webhooks to your systems, delivered through the same governed gateway.
Each deal watches the world that matters to it — allocation news on your build, congestion on your lane — scored on-box from the local feed store. And when an export-rule update postdates a clearance, the cockpit flags it: “re-screen advised.”
One tap builds a presentation-grade deal deck (print → PDF). A public, expiring link shares a marketing-safe live dashboard — aggregates only. And the stack plugs in: a scoped-key REST API, an MCP server for agents, and market benchmarks — every quote vs its forward band.
LLM Routing & Tokenomics: pick any Supermicro GPU configuration and see exactly which open-weight models it hosts (DeepSeek, Llama 4, Qwen, Kimi K2…), the vLLM launch spec and OpenAI-compatible endpoints it exposes, and the money: cost per million tokens vs market rates, margin, monthly revenue and capex payback at your utilization — plus the live serving estate and zero-egress routing posture.
V2 pulls the outside world in — weather, shipments, market volatility — through a single governed proxy. Only public queries leave; customer and deal data never do, and every outbound call is scrubbed and ledgered right next to the RBAC matrix and audit log. The trust boundary isn't the tax on world-awareness — it's what makes it safe. All the heavy AI still runs on your hardware; only routine, non-sensitive work can ever escalate, redacted, to a frontier model.
The brief was one sentence: run the entire deal, on the customer's own hardware, without ever trusting a single model on a call that matters. That resolves into three layers.
When the answer is facts, it's computed from the catalog and tier — never guessed.
When the answer is judgment, a heterogeneous panel of local models votes and an adjudicator reconciles.
The spine that carries a deal end-to-end, and the platform layer underneath every stage.
Almost the entire product is live on-premise today: the ten-stage lifecycle, the thirteen-person relay, the consensus councils, the world-aware pipeline, and the governed platform underneath. The short remaining roadmap is about wiring your real external systems.
The full feature matrix, every surface, a guided walkthrough, and the demo credentials live in the Documentation →.
The engine is done. Turning this beta into your production accelerator is a handful of decisions and connections — none of them a rewrite.
By default everything runs on one on-premise node inside your network — nothing leaves the box. Prefer cloud? The same stack runs on a VM in your own tenant. Your iPads reach it privately over Tailscale (HTTPS), never exposed to the public internet.
Load your real SKU catalog and pricing, set your client tiers, and point it at your CRM / deal database so every opportunity, customer and margin is yours — not demo data. Your data stays in your database; the app reads it locally.
Sensitive work always runs on the models on your box. You decide the rest with one setting: fully local, or let routine, non-sensitive work reach a frontier model — redacted first. A bigger box runs bigger local models.
Weather, shipment tracking and market signals stay off until you switch them on. Drop each provider's key into the Trust Center and flip the connector — every outbound call is scrubbed and logged, and customer data never leaves.
Graduate the demo PINs to SSO / your directory, so the audit trail carries real named accounts and access follows your org chart. A PIN brute-force lockout is already on; one-time codes land here.
Open the app in your browser and sign in as any of the thirteen seats. The demo credentials, ports and a guided walkthrough are all in the Documentation.
Point the accelerator at the system of record your team already lives in — accounts, contacts, open opportunities and pricing flow in through a governed connector. Seed the pipeline once from an export, or keep it in two-way sync so the deal tracker and your CRM stay aligned. Same discipline as every other feed: scrubbed, logged, and your data never leaves your box.