SPLII.ai
SpecializedProcessing forLow-energyIntelligentInference
Abstract
Most AI orchestration picks a model after seeing a task, runs it, and hopes. SPLII treats every request as a compilation problem. It lowers the request into a typed intermediate representation, applies governance as structural constraints, compiles several candidate execution graphs, and simulates all of them before any model runs. Candidates are ranked on confidence, latency, cost, compliance and power under an operator-chosen power mode. Only the winner executes, and the full decision, including every rejected alternative, is sealed in a hash-verified record that can be replayed to explain itself.
- Pipeline stages
- 0Pipeline stages
- Scoring signals
- 0Scoring signals
- Power modes
- 0Power modes
- Models in expert pool
- 0Models in expert pool
In plain English
§1 — System sheet
Specifications
| Category | Runtime decision compiler for AI execution — plans, simulates and scores before any model runs |
|---|---|
| Intent types | QUERY · ANALYSIS · TRANSFORMATION · VALIDATION · COMPOSITE (deterministic parse: same input → same intent) |
| Intermediate repr. | IntentIR { capabilities[], required_validations[], max_latency_ms, max_cost_units, power_mode, complexity_hint } |
| Policy actions | BLOCK_EXPERT · REQUIRE_VALIDATION · ENFORCE_LOCALITY · SET_MAX_COST · SET_MAX_LATENCY — applied before planning, never as post-hoc filters |
| Planning | N candidate execution DAGs per request: specialist-only · specialist + validator · generalist + validator (fallback) |
| Simulation | Σ latency · Σ cost · Π confidence · compliance-risk ratio · mean power efficiency — computed with zero expert invocations |
| Scoring | 5 normalized signals (confidence, latency, cost, compliance, power) × power-mode weight profile × escalation penalty |
| Power modes | eco · balanced · performance — the weight on power rises from performance to eco |
| Escalation gate | Complexity-adaptive confidence thresholds (simple < moderate < complex) on specialist plans |
| Execution | Rank-1 DAG only · Kahn topological order · frozen context · halt on failure · no implicit retries |
| Decision ledger | Every candidate, simulation and score sealed with SHA-256 over canonical sorted-key JSON · append-only |
| Replay | Counterfactual “why A, not B” — signal-by-signal deltas from the sealed record, no re-execution |
| Privacy proxy | Every model call leaves Synnc’s servers under platform credentials with a fresh request ID — the user’s IP address, device details and account are never forwarded. The provider receives the prompt and any memory context the user connects · TLS in transit |
| Locality tiers | on_device → edge → private_cloud → public_cloud → third_party, matched to data class (public → regulated) |
| Expert pool | Registered, not hard-coded: specialists, generalists (OpenAI, Anthropic, Google, xAI, Mistral, Perplexity…), validators, domain experts |
§2 — Decision → execution → provenance
How it works
Stage 1 · Intent
A deterministic parser turns the raw request into a typed Intent: QUERY, ANALYSIS, TRANSFORMATION, VALIDATION or COMPOSITE.
# sample trace[1] intent intent_type=QUERY power_mode=balanced
§3 — The math behind the choice
Simulation & scoring
Each candidate is a of expert nodes annotated with estimated latency, cost, confidence, locality tier and power class from the expert registry. Simulation aggregates those estimates without invoking a single expert.
Scoring normalizes five signals to [0, 1] and combines them with a weight profile chosen by the power mode. In eco the power term dominates; in performance confidence does. Plans whose specialist confidence falls below a complexity-adaptive gate are flagged for escalation and penalized, so a cheap plan that probably fails can’t win on price alone.
The same request can compile three different ways depending on the mode. The decision is computed, not configured.
L(D) = Σ_n ℓ_n # latency C(D) = Σ_n c_n # cost P(D) = Π_n p_n # aggregate confidence (product rule) R(D) = |flagged(D)| / |D| # compliance risk E(D) = mean_n η(power_n) # power efficiency, η ∈ [0,1] escalate(D) ⇐ specialist(D) ∧ P(D) < θ(complexity)
ŝ(D) = [ P, 1−norm(L), 1−norm(C), 1−R, E ]
S(D) = ρ_m(D) · Σ_k w_k(m) · ŝ_k(D)
m ∈ {eco, balanced, performance}
w(m) weight profile, Σ_k w_k(m) = 1
ρ_m escalation penalty (1 if no escalation)
D* = argmax_D S(D) → only D* executesdef decide(raw, power_mode):
intent = parse(raw) # 1 deterministic
ir = lower(intent, power_mode) # 2 capabilities, ceilings
pctx = policies.evaluate(ir) # 3 constraints, pre-plan
dags = planner.compile(ir, pctx) # 4 N candidates
sims = [simulate(d, pctx) for d in dags] # 5 no invocation
ranked = score(sims, power_mode) # 6
result = execute(ranked[0], frozen=True)# 7 topo order
return ledger.seal(intent, ir, dags, # 8 SHA-256
sims, ranked, result)> replay(decision_id, alternative="dag-e20") DAG 'dag-8ea' was selected over 'dag-e20' with a score delta of +0.047 (power_mode=performance). Selected advantages: confidence 0.702 vs 0.579 (+0.124) Selected disadvantages: power 0.417 vs 0.833 (−0.417) Alternative escalation note: specialist confidence 0.579 below threshold for complex task.
“Summarize what I promised the Acme team last week”
SPLII · privacy proxy
forwards req_7f3a92 · question + shared context · from Synnc servers
✓ Providers see Synnc
Every call leaves from our servers under our credentials — your IP, device and account never reach the provider.
✓ Request IDs ≠ user IDs
Each call carries a fresh ID, not your account ID.
✓ You choose the context
The provider receives what you type and any memory you connect — nothing else.
✓ Encrypted in transit
TLS from your device to Synnc, and from Synnc to the provider.
Fig. 2 — The privacy proxy: requests leave Synnc’s servers, so providers see Synnc — never the user’s IP, device or account. Sample data.
§4 — Temporal, evidence-linked, in production
The memory system
Facts change. Good memory remembers that they did.
The memory layer behind synnc.ai stores typed memories with validity windows. When a new fact contradicts an old one, the old one is closed and linked, not overwritten. So the system can answer both “what is true now?” and “what did we believe in March?”, and point to the exact source excerpt either way.
| Store | Postgres + pgvector, HNSW indexes over half-precision vectors |
|---|---|
| Embeddings | 3,072-dimensional (gemini-embedding-2) |
| Memory types | semantic · episodic · procedural · summary |
| Subjects | user · business · project · contact · product · workflow · decision |
| Time model | valid_from / valid_to per fact; superseded_by pointer — history is kept, never overwritten |
| Provenance | memory_evidence rows hold source excerpts; every synthesized page links back to the memories it came from |
| Graph | memory_edges: supersedes, related_to — plus wiki_links between synthesized pages |
extract → Utility model proposes typed memories; only confidence ≥ 0.70 survive dedupe → cosine > 0.95 against existing memory → treated as a restatement adjudicate → 0.85 – 0.95 → an LLM judges conflict vs. complement supersede → conflicts close the old fact (valid_to, superseded_by) and add a supersedes edge link → up to 5 related_to edges for neighbours in the 0.65 – 0.95 band compact → hourly compaction; low-importance memories archive at the cap
Procedural always injected Semantic cosine + recency boost, half-life 180 d Episodic cosine + recency boost, half-life 30 d Summary cosine + recency boost, half-life 14 d Wiki cosine + backlink and source-count boosts, de-duplicated, capped per page type Documents dense vector + Postgres full-text, merged; optional cross-encoder rerank
L0
Procedural
How you work. Always loaded into context — preferences and workflows are never left to chance retrieval.
L1
Semantic
Durable facts about people, businesses, projects and decisions. Slow recency decay.
L2
Episodic
What happened and when. Faster decay, so last week outranks last year unless relevance says otherwise.
L3
Synthesized wiki
LLM-maintained pages — profiles, relationships, goals, decisions — each linked to the evidence it was built from.
§5 — What runs where, today
Implementation status
| Component | Status | Notes |
|---|---|---|
| Decision compiler (stages 1–9) | Reference implementation | Python / FastAPI service with typed IR, DAG planner, simulator, scorer, ledger and replay. |
| Decision artifacts & counterfactual replay | Shadow deployment | TypeScript engine runs beside the live router, sealing SHA-256 decision records per request for audit and explainability. |
| Provider-blind privacy proxy | In production | Providers receive requests from Synnc’s servers, never from the user’s device — IP, device and account details stay inside. |
| Production routing (synnc.ai) | In production | Rules-based routing with manual override, plan gating and multi-provider failover; model discovery syncs provider catalogs daily. |
| Memory: temporal graph + pgvector | In production | Typed memories with validity windows, supersession, evidence and synthesized wiki pages. |
| Compiler-selected execution in production | Planned | Promote the shadow engine from audit to primary once offline evals clear the baseline. |
| Metered energy per decision | Planned | Today power is a per-expert efficiency rating; hardware-level metering replaces it next. |
§6 — Design principles
Why it’s different
Private by construction
OpenAI, Google, Anthropic, Mistral — whoever answers sees Synnc, not you. Requests leave our servers, so your IP address, device and account never reach the provider; only the prompt and the context you choose to share do.
Decide before you spend
Routers pick a model after seeing the task and hope. SPLII compiles and simulates several complete plans first — no expert runs until one plan has won.
Power is a first-class signal
Energy sits beside confidence, latency, cost and compliance in the objective, and the operator chooses the trade-off: eco, balanced or performance.
Governance shapes the plan
Policies remove forbidden experts and data flows before planning, so a non-compliant plan can’t be generated — not filtered after the fact.
Every decision is provable
A sealed record of every rejected alternative means you can audit, explain and replay any decision months later.
§7 — What’s on file
Patent pending
Runtime Decision Compiler for Artificial Intelligence Execution
The filed disclosure covers the decision pipeline, including:
- Intent → IR lowering
- Capability-based expert matching
- Runtime DAG synthesis
- Pre-execution simulation
- Structural policy enforcement
- Escalation gate with complexity thresholds
- Power-mode weight shifting
- Immutable decision-state artifacts
- Counterfactual replay without re-execution
- Human-in-the-loop override recording
- Federated locality-aware routing
§8 — For your product
Put SPLII in your stack
We build SPLII-governed AI systems for teams that need decisions they can audit: regulated workflows, private assistants, and agentic products where cost, energy and compliance matter as much as the answer. Bring your experts, policies and data classes, and we’ll compile them into a registry and a policy set.
Let’s build the impossible thing.
Hardware, software, AI or all three. Tell us what you want to exist — we’ll tell you how fast it can.
hello@synnclabs.comText or call us at any time · (934) 300-1042