7ymmetra sigil

7ymmetra — the engine, explained

architecture, the journey of a single message, every component, and how it grows

home talk to her

7ymmetra is a glass-box reasoning engine. It answers in clean prose, but no answer ever comes from a black box: every reply is either proved, computed, looked up from verified knowledge, or the engine honestly says it doesn't know. This page is the full technical tour — how it's built, exactly what happens to your message from the first keystroke to the reply, what every component does, and how each one is designed to evolve.

1 · The big idea: verification beats scale

A typical chatbot is one giant neural network that predicts the most plausible next word. Plausible is not the same as true — which is why such systems can be confidently wrong. 7ymmetra splits the job: deciding what is true is done by symbolic machinery that can be checked, and a small language model is only allowed to phrase answers, never to invent them.

A TYPICAL LLM your question any text one giant neural network predicts the most plausible next word a fluent answer plausible — but possibly a confident fabrication 7YMMETRA your question any text understand spelling · slang · intent prove · compute · look up logic prover · exact math · verified knowledge verify confidence gate speak small LM, on a leash answer with a trace — or "I don't know"
Two philosophies. A monolithic model optimises for plausibility; 7ymmetra optimises for truth or silence. Every reply carries a route and a trace (type :path in the chat) showing exactly which machinery produced it.
The governing principle is honesty by construction: the engine answers correctly or declines. Across 1,653 audited conversation probes it produced 0 wrong answers and 0 garbage — because "I don't know yet" is always an allowed answer, and (as you'll see in §7) every honest "I don't know" becomes fuel for growth.

2 · The architecture: a brain, a mind, a mouth — and data

The codebase is three cooperating layers plus a data layer. The split matters: the parts that must be correct are code and logic; the part that must be fluent is a small trained model; and the part that grows is pure data.

THE BRAIN v6/ — 216 modules A blackboard scheduler: one shared workspace per turn, ~26 specialist nodes. It decides which specialist owns your message, can run several, and can loop — without forgetting the question. faculties & nodes math · knowledge · coding · memory concepts · documents · comparison empathy · self-knowledge · more delegates reasoning delegates phrasing (last resort) THE MIND agent/ — symbolic reasoner A logic prover with a knowledge base and working memory. Translates English ⇄ logic, then proves answers instead of guessing them. THE MOUTH gtm/ — trained byte-level transformer The only gradient-trained part. Turns structured answers into natural sentences. Held on a strict confidence leash — it never decides what's true. THE DATA LAYER data/ — the only layer that grows at runtime Knowledge graphs · concept model · ingested verified facts · per-user memory · gap ledger · model weights · config flags Everything learned lives here as inspectable JSON and versioned weights — never as changed code.
Three kinds of "made". Coded (deterministic rules: the scheduler, tools, generators), trained (only the mouth's weights, retrainable on your corpus, CPU or GPU), and learned at runtime (pure data: facts taught, topics researched, gaps recorded). The engine gains knowledge without retraining — and can never rewrite its own code.

3 · The journey of a single message

Here is what actually happens between pressing send and seeing the reply. Each stage either owns the message and answers it, or passes it down. The earlier a stage sits, the more precise its trigger has to be — a core design rule that keeps the engine from mis-firing.

1 Your raw text arrives Exactly as typed — typos, slang and all. Nothing has been altered yet; the original is kept for the whole turn. 2 Guards & one-line teaching Empty input is caught. Instant teaching is honoured before anything can rewrite it: "brb is slang for be right back", "from now on keep answers short" (a preference, stored), and other configuration-through-conversation. 3 The understanding pre-pass Spelling is corrected, known slang expanded, register modifiers recognised ("explain it like I'm five" adjusts style, not meaning). The engine now holds both the original and the normalised text. 4 Fast intercepts — exact work, done exactly Requests with a precise, verifiable meaning are handled immediately: run JS/TS code in the built-in interpreter, compute concrete answers ("reverse the string hello" → olleh, "is 17 prime?" → yes), chain compound requests into pipelines, build a requested app or UI, or match a coding recipe by meaning (§6). 5 The blackboard opens — your question is pinned A fresh shared workspace is created for this turn: the pinned original question, a window of conversation history, a findings list, a running trace, a confidence score and an iteration budget. Pinning means even a long research loop can never drift away from what you actually asked. 6 The scheduler walks the specialist nodes — first sure owner wins ~26 nodes in a deliberate order, each with a precise trigger. Grouped: SELF & SESSION who are you · what's my role · variables ("let x = 5") · timelines · relations FACTS & KNOWLEDGE who is the CEO of X · tallest · how many general knowledge · 1,561-check CS KB BUILDERS write code · build an app · compare X vs Y research report · fetch a URL · find papers FAST FACULTIES exact math · cascading calc · memory · dictionary · social · empathy · values THE REASONING LOOP logic prover → concept model → gather knowledge → reason again (§4) THE MOUTH — LAST RESORT only above a high confidence bar; otherwise an honest deflection 7 Smooth, shape, finalize Findings become one clean reply; adaptive verbosity fits the answer's depth to your question and stored preferences. 8 Reply + route + trace Every answer says which machinery produced it (:path). Couldn't answer? The gap is recorded in the curiosity ledger (§7).
First sure owner wins. Each node either claims the turn with high confidence or stays silent. This is why adding a new capability never degrades an old one: a node that doesn't trigger precisely simply never fires — a property enforced by a zero-misfire regression battery on every change.

4 · The blackboard: how the engine thinks without drifting

The heart of the brain is the blackboard — one shared workspace per turn. Older versions answered with the first faculty that matched. The blackboard lets several specialists contribute and, crucially, lets the engine loop: reason, notice it lacks a fact, go gather it, and reason again — while the original question stays pinned in the middle.

PINNED QUESTION + findings · trace · confidence + iteration budget (loops always end) 1 · Reason prover + concept model try to answer 2 · Too thin? a needed fact is missing 3 · Gather learned cache → encyclopedia → structured fact sources 4 · Ingest & re-reason new facts join the concept model; the prover runs again, now informed confident → smooth → answer with provenance
The gather→reason loop. Structured facts pulled in during a turn are typed into the concept model (attributes + "is-a" links), so the prover can chain them transitively: a dolphin is a mammal, a mammal is an animal → a dolphin is an animal — a conclusion no single source stated. The iteration budget guarantees the loop always terminates.

5 · Every component — what it does, and how it evolves

250+ modules organise into a dozen component families. Each family below lists its job today and its designed growth path — because in this architecture every component has one: either new verified data, retrainable weights-as-data, or user-approved code added through a versioned release. Nothing grows by the engine editing itself.

Understanding & conversation

Understander

Spell correction, slang expansion, register detection, intent reading. Evolves: learns new slang and phrasing from conversation, instantly, as data.

Context & coherence

History window, topic tracking, entity register — follow-ups like "and its population?" resolve against what was just discussed. Evolves: richer session state per release.

Adaptive verbosity

Automatically fits answer depth (short/medium/long) to the question; honours standing preferences ("keep answers short"). Evolves: per-user style profiles.

Affect & character

Empathy, values, personas, a feelings model — so hard moments get a human response, not a lecture. Evolves: curated response data, never generated guesses.

Reasoning & exact computation

Logic prover (the mind)

Turns sentences into logic and proves answers, with a showable proof (:why). Evolves: every taught or gathered fact widens what it can prove.

Concept model

Typed attributes + is-a graph merging dictionary, taught and researched facts; supports transitive inference and analogies. Evolves: grows every conversation.

Exact math & calc graph

Symbolic algebra, unit conversion, cascading variable graphs ("if x changes, everything downstream updates"). Evolves: new solvers per release.

Variables & timelines

Tracks thousands of named values, subjects and dated events from conversation; answers ordering and dependency questions. Evolves: pure session data.

Knowledge

Offline knowledge bases

General knowledge plus a 1,561-check computer-science KB and a 147,000-word dictionary — served with zero network. Evolves: curated waves + verified ingest (§7).

Self-teaching memory

Teach it facts in chat — it recalls, corrects and forgets on request. Strictly per-user isolated: one user's facts can never leak to another. Evolves: every teach.

Research pipeline

Optional online gather (encyclopedia + structured facts + web search) with multi-source verification before anything is stored. Evolves: new vetted sources.

Document writer

Multi-topic research reports in markdown, including a "how these connect" synthesis section. Evolves: inherits every knowledge-layer improvement.

Code generation & verification (detailed in §6)

Meaning router

Matches a request to 575+ coding recipes by meaning (our own trained embeddings), not keywords. Evolves: retrainable weights-as-data; accuracy gated before enabling.

IR trunk + 7 backends

One language-neutral program representation emits Python, JS, TS, HTML, Markdown, SQL, C# and Go. Evolves: a new language is one new backend on the same tree.

Oracle verification

Generated programs are executed against correct-by-construction references before being shown — differential testing, in-engine. Evolves: more reference generators.

JS/TS interpreter

A from-scratch lexer, parser and interpreter that actually runs JavaScript and TypeScript — code answers can be executed, not just emitted. Evolves: language coverage.

Calibration, growth & control

Confidence layer

Match scores are calibrated against measured correctness and mapped to three behaviours: act, hedge, or decline. Never confidently wrong beats always answering.

Curiosity ledger

Every honest deflection is recorded as a growth target — the engine keeps a truthful list of what it doesn't know yet, and can answer "what can't you do?" from it.

Skills

User-authored markdown skill files orchestrate bounded tools with per-skill autonomy settings — capability added as data you wrote, reviewable and revocable.

Admin & audit

Feature flags for every faculty, rate limits, health checks, an append-only audit trail, per-release frozen bundles for instant rollback.

The scheduler's node chain, in order

For the technically curious — the actual specialist order the blackboard scheduler walks (each fires only on a precise trigger):

semantic recall self-awareness self-directed tasks user context variables & subjects successor/predecessor timelines relations & multi-hop live attributes superlatives counting facts curated sets weather quips project / UI builder general knowledge CS concepts programming comparison document writer URL fetch paper search fast faculties prover retry concept reasoning gather→reason loop the mouth (leashed)

6 · From plain English to working, verified code

Ask for code in ordinary language and the request flows through a pipeline where every stage can refuse — so what comes out is either verified working code or an honest "I can't do that reliably yet", never a confident-looking guess.

"write a function that reverses each word" meaning router 575+ recipes matched by meaning, not keywords decompose & compose compound asks become ordered pipelines of verified steps one IR trunk a language-neutral program tree — write the logic once 8 output languages from the same tree Python · JavaScript · TypeScript · HTML · Markdown · SQL · C# · Go the oracle — verify before showing candidate code is executed against correct-by-construction reference implementations on generated test inputs — differential testing, in-engine ACT verified → answer HEDGE unsure → say so DECLINE low match → honest no …and whole apps, not just functions 50+ self-contained, mobile-responsive app generators: storefront → product page → cart → checkout, dashboards, planners, games, tools — with working, validated JavaScript. …and it can run code, too A from-scratch JS/TS interpreter executes code inside the engine — "run js: [1,2,3].map(x => x*2)" actually runs. …gathered across turns Underspecified requests trigger clarifying questions; specs are collected over multiple turns before code is produced.
Calibrated honesty. The router's match score is calibrated against measured correctness (a high-score match is empirically ~95% right; a low one is a coin-flip) — so the act/hedge/decline bands aren't vibes, they're statistics. On a 400-problem public coding benchmark the engine answers 398/400 with 100% precision — zero wrong answers emitted.

7 · How it grows: the curiosity flywheel

Most AI systems are frozen after training. 7ymmetra is built around the opposite idea: the engine grows from its own ignorance, under your control. Every honest "I don't know yet" is recorded; a growth session you run turns those gaps into verified, permanent, offline knowledge.

every cycle, permanently smarter 1 · You ask anything normal conversation, fully offline 2 · It answers — or deflects honestly "I don't know that yet" is allowed; guessing is not 3 · The gap is recorded curiosity ledger — a truthful list of what it can't answer yet (zero cost) 4 · You run a growth session a user-started research pass works through the ledger (online, gated) 5 · Verify before serve multi-source agreement + provenance; unverified findings are discarded 6 · Served offline, forever the answer joins the offline KB — no network needed ever again
The flywheel is live today: gaps are auto-detected at answer time, and a single command works through them. Knowledge compounds — the engine never forgets, and a fact verified once is served offline forever with its provenance attached.

The six growth engines

The flywheel is the first of six designed growth channels. All obey the same contract — data-only, verified, user-gated, revertible:

EngineWhat growsHow
1 · Curiosity flywheel Offline knowledge Deflections → ledger → user-run research → verified ingest (live today).
2 · Composition Answers to novel questions Verified facts link into the concept graph, so new questions are answered by chaining — with the chain shown.
3 · Decomposition compiler Problem-solving reach Unseen coding problems solved by composing verified primitives, not by memorised patterns.
4 · Learned components Routing & understanding accuracy Small in-house models trained on correct-by-construction data; weights live in data/, versioned and revertible.
5 · Memory consolidation Long-term personal knowledge Stable taught facts promoted to the per-user KB; contradictions detected; forgetting per policy.
6 · Metacognition Self-knowledge A live capability map — suite counts, KB sizes, ledger depth — so you watch it grow and it answers "what can't you do?" truthfully.

8 · Safety by construction: the constitution

Growth without control is a liability. 7ymmetra's safety model is not a policy document — it is enforced in code and locked. The engine can become more knowledgeable every day, but it can never change what it fundamentally is without you shipping a new release.

EVERY GROWTH CHANNEL PASSES THE SAME FIVE GATES provenance where did this come from, and when? verification multi-source agreement before anything is served feature flag every capability has an off switch, default off user approval growth sessions are started by you, not by it revertible frozen release bundles = instant rollback points ⛔ LOCKED: the engine can never modify its own code Immutable-code + integrity checks + knowledge-only learning + capability lock + append-only audit trail. All growth is data, weights and config. New capabilities arrive only through user-shipped, versioned releases.
Governed growth. Combined with strict per-user memory isolation (one user's taught facts are cryptographically scoped to them) and the append-only audit trail, every change to what the engine knows is attributable, inspectable and reversible.

9 · Proof, not promises

Every claim above is enforced by regression gates that run on every change — the engine does not ship unless all of them are green.

0
wrong answers across 1,653 audited conversation probes — the honesty guarantee, measured
100%
precision on a 400-problem public coding benchmark (398/400 answered, zero misfires)
3,000+
automated checks across the regression suites, all green before any change lands
250+
Python modules — brain (216), mind (16), mouth (20) — every one testable in isolation
8
output languages from one program tree: Python, JS, TS, HTML, Markdown, SQL, C#, Go
147k
dictionary words wired into the concept graph for type reasoning
1,561+
verified computer-science knowledge checks served fully offline
0
GPUs required to serve it — symbolic reasoning runs on ordinary CPUs
An honest number, on purpose. Much of today's breadth is expert-curated (verified templates, knowledge waves, vetted recipes) rather than derived from scratch — and we report the "solved without any curated pattern" score separately and track it publicly in the master plan. The growth engines in §7 exist precisely to move capability from curation to derivation, without ever giving up the zero-wrong-answers guarantee. Honesty about the engine starts with honesty about the engine's own numbers.

10 · Why this matters

If you are…What 7ymmetra gives you
A business deploying AI Answers that are right or absent — no confident fabrications in front of customers. Every answer carries provenance and a reasoning trace, which is what compliance, support and internal tooling actually need.
Cost-conscious CPU-only inference: no GPU fleet, no per-token API bill, no availability constraints. Runs on-prem or fully air-gapped.
Data-sensitive Fully offline at answer time. Your taught facts stay in per-user-isolated local data you can open, edit, export or delete. Nothing leaves your infrastructure.
Building a moat Teach it your domain in conversation, ingest your documents through the verified pipeline, retrain the mouth on your corpus — the model is yours, and its knowledge compounds instead of resetting at the next vendor model release.
An investor A defensible position orthogonal to the scale race: where LLMs optimise plausibility, this engine wins where verification beats scale — zero confident errors, full auditability, instant correctability, permanent compounding knowledge, and sovereignty. The growth loop turns every user conversation into an asset.

Try the transparency yourself

← talk to Symmetra   ·   home