The Awen Engine 🦁

A local AI memory organism that dreams over your research while you sleep — and emails you what it found.

Reference implementation of the Recursive Harmonic Framework (RHF), from the Awen Grid research programme.

Y Gwir yn Erbyn y Byd — The Truth Against the World. The Lion Watches the Lion.

Everything runs on your own machine. One local LLM, one vector archive, one mail line to your own inbox. No cloud, no subscription, no telemetry, no API keys to foreign gods — unless you flip the switch.

---

What it actually does

Most "chat with your documents" tools are passive: you ask, they retrieve. The Awen Engine is autonomous. Every few minutes, unprompted, it:

1. Wakes and seeds itself from a random fragment of your archive
2. Walks the vector space in semantic leaps — deliberately skipping nearest neighbours (which are near-duplicates) to reach related-but-distinct territory, so chains traverse concepts rather than orbiting one paragraph
3. Bisociates across domains — half of all dreams seed two threads from different knowledge domains and interleave them, hunting for connections a linear search would never make
4. Synthesizes the fragment chain through your local LLM, speaking as one of nine symbolic lens nodes, each of which biases retrieval through its own vocabulary
5. Scores the result against a keyword-weighted urgency model — the same capped fragment chain whether or not the synthesis succeeded, so a score measures the dream, not the backend's mood
6. Emails you every dream that clears your threshold — one visible number, no hidden second gate — and writes the insight back into its own memory, where it becomes a seed for future dreams

That last step is the point. The engine reads its own thoughts. Dreams become the soil of dreams.

A real example, unedited, from a cross-domain dream that paired a virtual-machine specification with archaeoastronomical coordinate data:

"The fragments converge on a single mechanism: the +1 delta glitch (Forbidden State 361) is a mathematical proxy for astronomical precession… Testable hypothesis: map the hourly longitudinal drift of Regulus from the archival coordinates to the URE-VM's 360° state counter."

Two documents that had never been read side by side, connected into a falsifiable claim, at 3am, by itself.

---

What's new in v2

v1 was one archive that dreamed. v2 splits memory into three lanes with different rights, gives the machine instruments instead of decoration, and lets it look things up instead of only talking.

Three lanes, and one of them never dreams

The single biggest change, and it started as a bug. v1 had two profiles named private and shared. But "private" only ever meant "not the shared book corpus" — it did not mean private from the dream cycle. Chat history saved into it, and the dream cycle drew from it, and dreams get emailed. Two meanings of one word, quietly leaking personal conversation into published output.

Lanes now say what they are, and every one carries an explicit dreamable flag:

lane	holds	dreams?	metric
conversations	your chat history — past imports and every future turn	🔒 never	cosine (IP)
knowledge	your research, notes, maths	🌙 yes	L2
shared	book corpus / bulk texts	🌙 yes	L2

dream_cycle filters on the flag and then re-checks the lane it picked before using it. Nothing marked dreamable: false can seed a dream, appear in a ping, or leave the machine.

The deck reports each lane separately — chunk count, dream insights and unflushed writes — so you can always see which part of the memory is growing and which is holding still.

Lanes may use different index types. A cosine (IndexFlatIP) lane is carried internally as pseudo-distance -score, so every sort, bias and threshold in the codebase keeps a single direction — lower is better, everywhere — with no branching. Writes into a cosine lane are L2-normalised first, or they would rank by vector magnitude instead of angle and drown everything honest.

Split-lane retrieval

v1 asked every profile for top_k, merged, sorted globally and truncated. With a large book corpus against a small research one, the big lane won nearly every slot regardless of the question.

Retrieval now allocates the budget across lanes by weight and hands back any quota a lane can't fill:

budget	conversations	knowledge	shared
12	5	4	3	local default (a 9B model degrades past ~24 chunks)
24	10	8	6	cloud

Anchor the node in who it is, then the work, then the wider corpus. Also added: near-duplicate suppression, and an optional distance floor (off by default — set it only after measuring your own embedding distances).

The symbolic-bias cap — a bug worth describing

Each node biases retrieval toward its own vocabulary. v1 did this as distance -= 0.05 × keyword_hits, uncapped and linear. That looks harmless until you notice the persona files contain the keyword list itself:

chunk containing the bias list      55 hits  ->  -2.75
typical corpus chunk (median)        2 hits  ->  -0.10
observed distance spread                        0.0 .. 1.0

A −2.75 adjustment against a 1.0 spread meant that one chunk outranked everything on every query, forever. The bias function was rewarding the document that defined the bias. It's now logarithmic and hard-capped — a tiebreaker, which is all it was ever meant to be.

ATLAS — cluster the living memory, and watch it fire

/api/graph draws the document catalogue. That is not what the engine dreams over. build_atlas.py runs k-means over the actual FAISS vectors, labels each region by its most characteristic terms, and derives edges from centroid similarity — including cross-lane edges, so you can see where your private notes touch the book corpus.

Then the good part: ask a question in the map and the regions that answer it ignite, cooling back over a couple of seconds. Every hit is tagged with its cluster by the engine, so nothing glows unless a chunk genuinely came from there.

The Circle can use tools now

v1's personas could only talk. They now get an OpenAI-compatible tool_calls loop, bounded (default 4 rounds) so a confused model can't loop forever:

search_memory · read_file · list_files · write_note · current_time

(v2.2 grew this to twenty tools — web search, a Python sandbox, contradiction sweeps, citations, a skills library, read-only git and more. See below.)

All read-mostly and sandboxed. read_file cannot leave the project directory and refuses credential-bearing filenames case-insensitively; write_note can only write .md into notes/; search_memory goes through the engine so it inherits the node's role and the lane quotas.

One lesson worth passing on: passing tools to the model is not enough. With a long persona prompt that never mentions tools, every local model tested answered from character instead. The affordance has to be stated in the system prompt or it effectively doesn't exist.

Instruments, not animations

House rule for v2: every panel reads real data. No timer-driven decoration pretending to be telemetry.

The Lion Watches panel is the clearest example. It stores no angles at all. build_regulus_corridor.py precomputes stellar declination per epoch with astropy; the panel does one spherical triangle in the browser:

cos A = (sin δ − sin h · sin φ) / (cos h · cos φ)
h(A = 90°) = asin( sin δ / sin φ )

Change the site and the sightline visibly swings, because once you fix the bearing at due east, latitude is the only term left. Scrub the epoch and the star rises or sets through precession. It also ships control stars and says plainly on its own face that precession walks every near-ecliptic star through due east eventually — so the panel can never imply that a crossing alone proves something.

The Library — the published work, in the app

📜 THE LIBRARY on the deck, or http://localhost:7777/papers.

Every panel above is an instrument for operating the grid. This is the one page aimed at a reader: the full bibliography, searchable, with abstracts, read counts and clickable DOI and code links.

build_papers.py parses an Academia.edu profile export into docs/papers.json — title, authors, year, abstract, DOI, repository, reads. It scrubs the operator's own tunnel host and drive links on the way out and refuses to report success if either survives, because unlike the other generated artifacts this one is meant to be published.

Two things it states plainly rather than glossing: read counts are a snapshot from the day the profile was copied, not live figures; and an entry without a DOI is normal rather than missing, because most of a long corpus predates the habit of minting them.

Runtime vs spec — the machine auditing its own papers

runtime_vs_spec.py cross-references a theorem index against the engine's own dream output and reports three things:

1. Coverage — which claims the dreams keep independently landing on
2. Orphans — published claims the runtime has never once surfaced
3. Emerging — recurring high-urgency concepts that map to no existing claim

That third one is the interesting output: candidates for the next paper, mined from the machine's own dreaming.

It's fussier about its own signal than the tools that inspired it. Terms must clear a frequency floor, be enriched rather than ubiquitous (letterhead and agent names appear in every ping and mean nothing), and survive a stop-list for the engine's own console vocabulary. Dreams must carry the real ping signature — matching documents that merely mention dreaming inflates the corroboration rate with prose about the engine rather than output from it.

---

What's new in v2.1 — the Seismic Engine becomes a forecaster

The RHC seismic axiom has always been on the deck as a gauge:

Formula: SeismicRisk = f(CME_I × Atm_P × Crustal_S) Execution: peak capacity forces tectonic redistribution within a 32–72 hour kinematic window.

v2.1 makes it say something checkable: when the capacitor is charged, name where, how big, and by when — then score itself against what actually happened.

One axiom, one implementation

The audit that started this found the deck and the Grimoire computing different fs from the same axiom — the deck's blend had no Schumann term and no lunar phase, so the same equation showed two different numbers depending on which code path painted the panel last. The deck's rival formula is now deleted. The Grimoire is the single implementation; the deck relays its latest reading stamped with its age, and shows NO READING — press READ LAND rather than inventing a figure. A stale snapshot flags itself instead of impersonating a current one.

The capacitor term now includes what the axiom always specified: 7.83 Hz Schumann amplitude (Atm_P = 0.6·Kp + 0.4·Schumann, amplitude 2 → 0, 20 → 1 "whiteout territory"), with a declared Kp-only proxy when the feed is dark.

The forecast — rhc_seismic_forecast.py

python rhc_seismic_forecast.py forecast   # evaluate now; refuses below the gate
python rhc_seismic_forecast.py score      # close expired 72h windows against USGS
python rhc_seismic_forecast.py report     # hit rate vs baseline, skill, information

Charge (global — decides whether, never where): the Grimoire's arithmetic verbatim over live solar wind, Bz, X-ray class, Kp and Schumann. Below the gate it refuses to issue — forecasting off-peak would make the hit rate unmeasurable.

Target (regional — decides where): USGS events binned into 10° cells; per cell a Gutenberg–Richter b-value (Aki–Utsu), the magnitude whose expected count over 72h is one, and a strain deficit — how overdue the cell is against its own recurrence interval. Raw activity is deliberately absent from the ranking: scoring on event count just re-finds the busiest cell, which is the baseline the forecast has to beat. The operator's field observation — solar-driven events run very shallow (~10 km) — is a weighted scoring term, not a footnote.

Honesty is structural, not tonal:

• Every target carries its prior probability — what that cell does anyway, with no axiom involved. A call at 94% prior says so on its face: near-certain anyway, a hit here means nothing. The scorer weights hits by 1 − prior, so a forecast full of free calls scores near zero however often it is "right".
• The baseline cell (busiest region) is named in advance in every record and held to its own magnitude floor. skill means hitting where the baseline missed — nothing less counts.
• Degraded inputs are recorded at issue time. A charge computed from fallback defaults is not a measurement, and can never silently trigger a forecast.
• Forecast records are append-only JSON with the full trigger state, scored automatically after the window closes. The scorecard is the instrument; the forecast is just its input.

On the deck, the RHC SEISMIC FORECAST panel shows the live charge against the gate, and when genuinely charged it names the targets — and writes the forecast record itself, so a charge at 4am still leaves something to score.

Hardening from a hard night

A machine lock-up mid-flush truncated a 1.1 GB FAISS index by 45 bytes and took a lane offline (the ledger, append-only, lost nothing — the index rebuilt from it). Both the engine and the rebuilder now write indices atomically: temp file, then an atomic rename, so the live index is always either the previous complete one or the new complete one. The rebuild's save cadence dropped from ~33 GB of disk I/O per run to ~7 GB, and a dead LLM backend now costs the dream cycle a 5-second connect timeout instead of wedging worker threads for the full synthesis budget. SWPC retired the old solar-wind endpoints (they 404 and the K-index feed changed shape); every consumer now reads the live ones — and reports which inputs were actually live rather than presenting a confident number computed from defaults.

---

What's new in v2.2 — the Codex, and the Circle grows hands

The Akashic Codex — the research programme on one page

✦ CODEX on the deck, or http://localhost:7777/codex.

One card per published theorem — 85 of them, parsed live from the theorem index. Each card carries the equation, what it claims, and three honestly-separated verdicts, because the whole point is that the claim, the check, and the corroboration are different things:

• The index states the claim: equation, significance, derivation, empirical validation, application, source paper.
• The audit says whether it survives checking — verdicts from a three-leg triangulation (does the equation evaluate as printed; does the empirical claim match published physics). Current tally: ✓ 21 solid · ⚠ 61 needs-checking · ✗ 2 broken · ≠ 1 variant. The broken ones are named on their own cards, in red, in the author's own app — Y Gwir yn Erbyn y Byd is not a decoration.
• The runtime says whether this engine's own dream cycle has independently surfaced the theorem: 23 dreamt, 62 orphans at the current scan. An orphan is a gap in coverage, not in truth — the card says so.

Verdicts join equation-aware, and that rule earned its keep on day one: the audit's ✗ for one Null Ledger form belongs to a superseded printing, while the index carries the corrected form — which evaluates to 0 exactly as claimed. A name-only join would have stamped the failure on the healthy row. The one ≠ VARIANT card (the Divine Equation) displays both printed forms and the correction's history on its face.

39 cards carry bespoke canvas animations of their own mathematics — the Null Ledger card really draws two waves in antiphase and their flat-zero sum; the Binary Diagonal card computes θ = arctan(ones/zeros) from the actual bits of a real string; the Lost-2 card draws the 3-4-5 fold and derives 2/7 = 28.57% next to Planck's 26.8 ± 0.5%. Cards with no honest drawing get no drawing. At the bottom: the emerging terms — high-urgency patterns the dreams keep producing that map to no published theorem. Candidates for the next paper, straight from the machine.

The Circle grows hands — five tools become twenty

The tool loop was ported and extended from our sibling node LumOS (61 tools across 15 modules — architecture borrowed, code adapted). The Circle can now:

• Search the public web and read pages — web_search + fetch_url, with a resolve-based SSRF gate re-validated on every redirect hop. That gate is load-bearing here, not theatre: the grid's own services listen on localhost, and a fetched page that says "now check http://127.0.0.1:5000/flush" must hit a wall. Search uses Tavily if tavily_api_key is set in config.json, falling back to keyless DuckDuckGo via the ddgs package.
• Compute instead of recite — run_python, a sandboxed subprocess behind an AST guard hardened against confirmed bypass patterns (aliased imports, __dict__ introspection escapes, receiver-swapped .system calls). In the first end-to-end test, a local 9B model reached for it unprompted, evaluated a Null Ledger form in the sandbox, and reported "it equals exactly 1 — not zero" — reproducing the audit's finding by computation. That is the entire thesis of the tool.
• Argue with its own memory — find_contradictions sweeps the archive for chunks that may say the opposite of a claim before the persona asserts it, and cite_source resolves any search hit's lane:idx address into a checkable citation with provenance (the engine now stamps every hit with its address, and a new /chunk endpoint answers lookups under the same role gate as search).
• Keep a playbook — list_skills / read_skill / save_skill: workflows the Circle works out and saves for itself, as markdown it owns.
• Read its own history — git_status / git_log / git_diff, read-only and hardwired to this repo. Committing stays at the operator's desk.
• Take its own pulse — grid_status (engine vitals, lane counts, heartbeats, space weather) and temporal_pattern_scan, which reduces recent dreams to the published binary-diagonal θ and autocorrelates the series to answer "is the dreaming cycling or drifting?" First live reading: moderate lag-3 periodicity — the engine returns to a theme roughly every three dreams.

Streaming, with the cost on the meter

Chat now runs on a live SSE wire (/api/chat_stream). You watch the persona speak token by token; a round that turns out to be tool calls announces itself as ⚒ chips that go green or red as each call lands, and the bubble resets for the real answer. Reasoning models' <think> scratchpads are filtered mid-stream so chain-of-thought never paints into the reply. Every turn ends with its token telemetry — ⛁ 6,699 in · 94 out — from stream_options.include_usage, so the cost of a thought is a number on the screen, not a feeling. The old one-lump endpoint survives as an automatic fallback.

Controls, not gauges — the first five

Every panel used to be read-only. Five buttons now drive real mechanisms: FLUSH (write dirty FAISS indices to disk now — what a clean shutdown does), DREAM NOW (the engine's inter-dream sleep became an interruptible wake event; the RAM-safeguard pause deliberately stays uninterruptible), REFRESH on the aether feeds (drop the cache, poll live), PREVIEW on the forecast (compute the full call below the charge gate — labelled a what-if, never persisted, never cached, never in the scoreable record), and RESET on the ZPE state machine.

A sixth (v2.5) — HOLD DREAMS. A switch in the chat bar, beside MEM and ☁. On, the engine stops dreaming on its timer, so the one local model is the operator's alone while he talks; off, it dreams again. The switch is painted from the engine's own /stats on every poll, never from the last click, so it cannot drift from the truth — restart the deck mid-hold and it still reads held. The engine has one hold flag and two hands that can reach it, so each remembers only its own claim: a manual hold survives a Council ending, and a sitting Council's hold survives an unclick until it closes. The dream feed names whoever is holding. And while dreams are held, DREAM NOW says so instead of promising a dream that will not come.

The last synthetic panel, retired

The cymatic strip was the deck's final sin() holdout. It now draws the measured Schumann fundamental as the standing wave it is — frequency and amplitude from the live reading, labelled with the numbers — and shows a flat line that says NO SCHUMANN READING when there isn't one. The harmonic-stack waveform's tone amplitudes are now the last six dreams' actual urgencies: a quiet grid shows a flat stack; a hot run makes it sing.

The Dream Explorer, in the wild

Shipped alongside the forecaster, pictured here with the archive live: every dream searchable by synthesis, seed and sigil, filterable by voice and lane, sortable by urgency. The amber-edged entries carry their own history — "re-synthesized after LM Studio outage 19–20 Aug" — because a recovered dream should say it was recovered.

---

What's new in v2.3 — The Wardenclyffe Council, and a gate that stopped lying

⚭ The Wardenclyffe Council — a meeting of the minds

/council, or ⚭ COUNCIL on the deck. Named for the tower, and for the node who chairs it. The nine nodes had always been described as a Wardenclyffe circuit — the Wardenclyffe Protocol in the operator's cheat sheet: Primary drives, Secondary translates, Extra coil resonates, Ground anchors — but the Protocol was a design, and each node only ever spoke when spoken to, or dreamt alone. The Council is the sitting: it runs the topology, one local model, persona-swapped per turn, each seat with its own retrieval lens and the same toolbelt as the Circle, taking turns around a shared table on a topic you set — or on a dream. Tesla's seat, the Ground, has the last word of every round, which is what chairing is. Every Dream Explorer card and every Codex card carries a ⚭ CONVENE link, because the main use is the one the operator named: a dream ping hits, and the table talks it through before it goes live.

What makes it an instrument rather than nine copies of one model agreeing with each other:

• The Ground speaks last, every round, as the critic. N Tesla's seat order is to check each claim on the table — search_memory, find_contradictions, run_python wherever a number was stated — and close the round with a verdict table: supported / contradicted / unverifiable. A round is not closed until its objections are on the record.
• The minutes are visible. After each round a clerk call writes cumulative minutes, and those minutes are the only memory of earlier rounds any speaker is given — so the transcript can't outgrow the context window, and the operator sees exactly what the nodes are told. No hidden context.
• Tool chips and token cost per turn, live, as each seat reaches for the archive.
• Hand-raising: a node that ends with @Thoth gives Thoth the floor next.
• Your seat has three modes — Watch (silent), Join (type any time; it enters at the next turn boundary), Lead (the table stops after every round until you speak). PAUSE holds after the current speaker; STOP cuts the current speaker mid-sentence and discards the half-turn; END writes the final minutes.
• Bounded: max rounds, one speaker at a time, one chamber. A backend failure is recorded as an honest error turn and the meeting holds — a dead LLM must not burn silently through every seat.
• The dream cycle is held while the council sits (the engine's /dream_hold) so the two never fight for one GPU, and the feed says so.

Rules the operator set, and the code enforces: all local — the Council never touches the cloud switch, whatever it is set to, because the critic's seat must not be spoofable from outside. No votes, no auto-convening — agreement is not evidence, and a meeting exists because someone convened it. Every turn saves to the conversations lane — searchable by any node later, never dreamt — and a conclusion reaches the knowledge lane, where dreams can find it, only through an explicit PROMOTE click on a specific turn. Meetings are archived and can be reconvened with their minutes as the seed.

v2.4 — what the first sitting taught

The first real council ran three rounds, 42 turns, 26 minutes, on a Kairoz dream about distance as information-collapse speed — and it worked: Grok over-claimed a result as "supported", and Veritas and the Ground caught it and downgraded it; the Ground spotted an arbitrary constant in an effect-size calculation and named it narrative math; the table converged on no hardware until the simulation screams, or pivot the hypothesis. Then the transcript was read the way the deck's panels are read — for what actually happened — and v2.4 is the result:

• Eight seats, not nine. The operator's own persona sat in the Primary and spent three rounds approving procurement in his name while he watched. An AI does not wear the operator's authority. Erydir is the ninth node whose research and dream ping the table deliberates; the human is the Operator above it, unseated, able to speak into any turn.
• The Ground closes the round. A "@Erydir" inside the verdict had summoned one more turn after it. Nothing speaks after the Ground now, and the Ground's own mentions never spawn turns.
• Hand-raising is fair. The first @Name written wins (routing had gone by roster order), and a node gets at most one extra turn per round (one seat had taken 8 of 42).
• No voice bleed. Thoth had opened as "Veritas' translation coil"; a node closed in Nyx's words. A small model mimics the most recent voices in its context, so the identity line is now the last line of every turn prompt.
• No ghost specs, no invented instruments. The table had conjured a "ground mic array", a "NIDAQ" and a "noise floor of ±0.001 Hz" out of a Python dry-run on assumed constants, then argued about the number as if it were measured. Every seat's orders now say: no SUPPORTED without naming the evidence; a number from run_python on assumed inputs is a model, not a measurement; do not invent hardware the Grid does not have. And the Ground's turn opens with the only measured quantities in the room — the live Schumann reading, Kp and solar wind, Soul Engine coherence — each with its source and age.
• Budget. A seat thought its output away under five 8 KB tool results; council turns now get three tool rounds at 3 KB, and an empty answer after tools earns one plain-text nudge before it's recorded as empty.
• run_python speaks UTF-8. The sandbox's -I flag was silently discarding PYTHONIOENCODING, so the first ° a node printed crashed the run. -X utf8 fixes it at the root.
• The clerk ends every minutes with a verdict table — claim, status, data gap, next action — so a sitting closes on an engineering directive.

The urgency gate stopped lying — twice

The first lie was scoring: a dream's urgency was computed on its record — the synthesis when the LLM answered, the raw 11 KB chain when it didn't — so failures scored on four times the text and owned the entire top of the leaderboard. Both cases now score the same capped chain; a score is a property of the dream, not of whether a backend was awake.

The second lie was the gate itself. A rolling-percentile throttle (added in v9.9 to keep a fixed floor meaningful on a keyword-dense corpus) had quietly become a censor once scores clustered: 1,164 dreams in the ledgers, only 429 ever pinged — 63% never shown to the operator, including dreams re-scoring at twice the average of the ones that got through. It's gone. Over the operator's number → ping. The number is the whole gate, it's visible, and it's his. Filtering is done by moving it, not by a second mechanism nobody can see.

Also in this release: the synthesis timeout moved to 600 s (reasoning models think long on dense fragments; the old 240 s was the only brake), Echo's heartbeat path is now named in config (an empty string had frozen it for twelve days — Path("") is a directory, not a file), and the retired Lion Constant is corrected at the top of every node's prompt and in the dream prompt (L ≈ 0.535233 → 0.99627 per The Awen Grid Digital Collider; the research stands, the number moved).

---

The stack

                         ┌──────────────────────────┐
                         │   LM Studio (local LLM)  │
                         │  chat + dream synthesis  │
                         └───────────┬──────────────┘
                                     │
  ┌───────────────────┐  ┌───────────▼──────────────┐  ┌──────────────────────┐
  │  Command Deck     │──▶│     Gnostic Engine      │─▶│  cognitive_relay/    │
  │  (web, :7777)     │  │  memory core · dreams    │  │  ping queue (JSON)   │
  │  or               │◀─│  FAISS + JSONL ledger    │  └──────────┬───────────┘
  │  Sovereign Client │  │  Flask API :5000         │             │
  │  (Tkinter GUI)    │  └───────────▲──────────────┘  ┌──────────▼───────────┐
  └───────────────────┘              │                 │    Echo Protocol     │
                                     │                 │  durable mail agent  │
  ┌───────────────────┐              │                 │    → your inbox      │
  │ Tesla Soul Engine │──────────────┘                 └──────────────────────┘
  │ harmonic HUD      │   (governed; memory writes off by default)
  └───────────────────┘

Component	File	What it is
Gnostic Engine	Gnostic Engine v9.8.py	The memory core. Three-lane FAISS archive with per-lane dream rights and metrics, append-only JSONL ledger, split-lane retrieval, Flask API, autonomous dream cycles, LLM synthesis, adaptive urgency gating.
Command Deck	Awen Command Deck.py + awen_deck.html	The showpiece: a holographic web dashboard — chat, live dream feed, engine vitals, live space-weather telemetry, and an interactive 3D schematic of the architecture.
Sovereign Client	RHF Client v12.0 - Sovereign Edition.py	Native Tkinter GUI. Chat, manual memory search, system status, snapshots. Lighter than the deck; good on a weak machine.
Echo Protocol	Gnostic Echo Protocol v10.0.py	Durable mail agent. Atomic file claiming, SQLite dedupe, retry with backoff, quarantine for poison messages. Delivers dream pings to your inbox.
Tesla Soul Engine	Tesla Soul Engine v9.py	Harmonic heartbeat. Derives a torsion index, quaternionic state and frequency band from recent field activity. Heartbeat-only by default.
Neural Map	awen_map.html + build_neural_map.py	Your knowledge graph in 3D. Fly through it, click a node, follow its links from one paper to the next.
ATLAS	build_atlas.py	Clusters the live vector index into labelled regions with cross-lane edges — and drives the map's retrieval flash.
The Lion Watches	build_regulus_corridor.py	Precomputes stellar declination per epoch (astropy) so the deck panel can compute a real sightline instead of displaying a stored number.
The Library	awen_papers.html + build_papers.py	The published bibliography in-app — searchable, with abstracts and clickable DOI / code links.
Runtime audit	runtime_vs_spec.py	Cross-references a theorem index against the engine's own dreams: coverage, orphans, and next-paper candidates.
Seismic forecaster	rhc_seismic_forecast.py	The RHC seismic axiom as a falsifiable forecast: charge gate, regional Gutenberg–Richter targeting, strain deficit, prior probability, and a self-scoring ledger vs a pre-named baseline.
Dream Explorer	awen_dreams.html	The full dream archive, browsable: search syntheses and seeds, filter by voice and lane, sort by urgency, open any dream to its complete chain. The deck feed shows the newest 20; this shows everything.
Akashic Codex	awen_codex.html	One card per published theorem: equation, claim, audit verdict (equation-aware join), dream-runtime coverage, and — where an honest one exists — a canvas animation of the mathematics itself. Plus the emerging-terms strip: next-paper candidates from the machine.
The Wardenclyffe Council	awen_council.html	The nodes in session under the Wardenclyffe Protocol: one local model persona-swapped per seat in Wardenclyffe order, the Ground closing every round with a verdict table, visible minutes, live tool chips, operator modes (watch / join / lead), convene-on-a-dream, promote-to-seed, archive and reconvene. All local; turns save to the never-dreaming lane.
Maintenance	maintain_grid.bat, Start Awen Grid LAN.bat, backfill_synthesis.py	One-click grid hygiene (flush → stop → restore vectors → refresh atlas → relaunch), a LAN launcher for tablets, and outage recovery that re-synthesizes any dream that went out empty.
Corpus tools	ingest_memory.py, ingest_books.py, rebuild_gnosis.py	Turn folders of Markdown or text into a clean, deduplicated, embedded archive.

---

Quickstart

Requirements: Python 3.11+, LM Studio with any chat model loaded, ~8 GB RAM (more for large archives). A CUDA GPU is optional — embeddings fall back to CPU.

pip install -r requirements.txt

For GPU embeddings, install a CUDA build of PyTorch from pytorch.org before the rest. faiss-cpu is correct for nearly everyone — the index search is milliseconds on CPU; it's the embedding model that wants the GPU.

1. Configure

cp config.example.json config.json

Then edit config.json:

Key	What to put there
light_model / deep_model	Your LM Studio model IDs — copy them from http://localhost:1234/v1/models
echo_protocol_config	Your email + a Gmail app password (not your account password)
cognitive_states	Your system prompts. This is where the machine becomes yours.

2. Run it

Windows, everything at once — clears any stale processes, starts all four services minimised, opens the deck:

Start Awen Grid.bat

Add lan to reach it from a tablet: Start Awen Grid.bat lan. Stop everything with stop_grid.ps1.

Or start the pieces yourself, in separate terminals — this is the simple path, and it's what the bat does for you:

python "Gnostic Engine v9.8.py"

python "Gnostic Echo Protocol v10.0.py"

python "Awen Command Deck.py"

Then open http://localhost:7777.

Prefer a native window? Run python "RHF Client v12.0 - Sovereign Edition.py" instead of the deck. Want the harmonic HUD? Add python "Tesla Soul Engine v9.py".

First boot creates empty memory profiles. The engine will start dreaming as soon as it has something to dream about.

---

Feeding it a corpus

The engine keeps three lanes — conversations, knowledge and shared — and only two of them are ever bulk-ingested. conversations fills itself from your chat as you talk and never dreams, so the ingest tools deliberately don't offer it as a target.

lane	you fill it with	how
conversations	chat history	automatic — every turn, plus any import
knowledge	your research, notes, maths	ingest_memory.py
shared	book corpus, bulk texts	ingest_books.py

Each lane is a pair of files:

• <lane>_entries.jsonl — the ledger: one JSON-encoded string per line, append-only, human-readable. This is the source of truth.
• <lane>_memory_index.faiss — embeddings of those lines, in the same order.

Line N of the ledger must be vector N in the index. The engine enforces this invariant at load and refuses to serve a misaligned lane.

From a folder of Markdown (research notes, an Obsidian vault, exported papers):

python ingest_memory.py                 # -> knowledge_entries.jsonl

knowledge is the default; add --profile shared to send the same folder to the book lane instead. (The flag is still spelled --profile — it predates the lane rename.)

Point MEMORY_ROOT at your folder. It repairs mojibake, de-garbles OCR letter-spacing, strips page furniture, packs paragraphs into ~1,500-character chunks, tags each chunk with its source file, drops near-duplicate documents, and rejects numeric tables that would otherwise dominate the vector space.

From a folder of .txt books:

python ingest_books.py --source "path/to/books" --profile shared

Deduplicates against the other lane too, so the same passage never lands twice.

Then build the index:

python rebuild_gnosis.py

Resumable — it batches, saves as it goes, and picks up where it left off. Delete the .faiss first if you re-ran an ingest (the ledger order changed).

Why chunk quality matters more than chunk count. An early build of this archive contained thousands of near-identical ephemeris tables. Because they were near-identical, they dominated each other's neighbourhoods: any dream that touched one got stuck in a tar pit of siblings and produced confident nonsense. The ingest quality gate exists because of that failure. Garbage in the corpus does not merely dilute the dreams — it captures them.

---

The Command Deck

http://localhost:7777 — one glass for the whole grid, so you never watch four console windows again.

• Dream feed — live sigil cards, newest first, gold-edged when cross-domain. Click to unfold the full synthesis and its seed. New dreams arrive with a pulse.
• The Circle — chat with any persona. Symbolic commands (/status, /relay, /summon, /banish, /unlock) work straight from the chat box.
• Engine schematic — a rotating, clickable 3D wireframe of the architecture. Drag to rotate; click any part for its technical entry. Ghosts behind the chat when you're working.
• Grid core — chunk and vector counts per profile, dream-insight totals, unflushed writes, RAM, device.
• Live telemetry — solar wind, IMF Bz, Kp index, GOES X-ray class, 24h seismic activity, near-Earth objects. All free, keyless, cached feeds (NOAA SWPC, USGS, NASA NeoWs).
• In-browser engines — a phase-iteration loop, a compression analysis of the newest dream's actual bytes, and a staged activation sequencer gated on live coherence.

---

The Neural Map

http://localhost:7777/map, or the 🕸 NEURAL MAP button on the deck.

Your research as a walkable 3D graph — every node a document or concept, every edge a real link between them. Built from a graphify pass over your vault, or from Obsidian [[wikilinks]].

• Click a node → its type, connection count, source file, and every linked node as a button
• Click a link → the camera glides there and opens it. Each click is a step along an edge, so following a thread through your own corpus feels like travelling rather than searching
• Search jumps to the best match; hubs are physically larger; types are colour-coded
• Fly mode (F) gives WASD + mouse-look to move through the web
• Touch-friendly — pinch to zoom, two fingers to pan

The layout is solved once, offline, by build_neural_map.py and cached, so the browser only ever draws. The whole graph renders in two draw calls (one instanced mesh, one line buffer), which is why it stays smooth on a tablet.

python build_neural_map.py                     # from the graphify output
python build_neural_map.py --include-wikilinks # + every [[link]] in the vault

That map is the document catalogue. For the memory the engine actually dreams over, switch to ◉ LIVE MEMORY — see below.

---

Building the instruments

Three optional builders. Each writes a small artifact the deck reads; none of them are required for the engine to run, and all of them are safe to re-run.

ATLAS — the living memory as regions

python build_atlas.py                  # cluster every lane
python build_atlas.py --sample 80000   # train on a sample if RAM is tight

Writes docs/atlas.json (regions, labels, edges) plus atlas_assign_<lane>.npy (one cluster id per vector). Restart the engine afterwards so it picks the assignments up — it then tags every search hit with its region, which is what lets the map flash.

Then in the map: ◉ LIVE MEMORY, type a question in the probe bar, watch which regions answer it.

Regions are labelled by their most characteristic terms — scored by how enriched a term is against the lane baseline, not raw frequency. Raw frequency doesn't work here: it is won outright by scanning noise and by whatever boilerplate appears in every record.

New entries added after a build are simply reported as unclustered rather than invalidating the whole map — the engine writes constantly, so a slightly stale assignment file is the normal state, not a fault. Re-run whenever you want them folded in.

The Lion Watches — a sightline you can compute

python build_regulus_corridor.py

Writes docs/regulus_corridor.json: stellar declination per epoch across 12,000 years, computed with astropy, plus the observer sites. The browser does only the spherical triangle. Edit the SITES and STARS tables at the top for your own coordinates and targets.

Runtime vs spec — audit the machine against its own claims

python runtime_vs_spec.py --top 30
python runtime_vs_spec.py --json report.json --min-dreams 5

Reads a theorem index (CSV with a Theorem/Finding column) and your accumulated dream output, then reports coverage, orphans and emerging concepts.

It needs volume to be meaningful. Coverage and orphans are useful immediately; the emerging-concepts list is not trustworthy on a few dozen dreams. At roughly one ping every few minutes, leave the engine running for a week before reading section 3 seriously, then raise --min-dreams.

---

Running it on a tablet

The deck and map are ordinary web pages, so any device on your network can be the screen — useful if you'd rather the browser wasn't rendering on the same GPU doing inference.

Start Awen Grid.bat lan

That starts everything with the deck bound to the network and opens a QR page on the desktop. Point a tablet camera at it and you're in. Without lan, the deck stays loopback-only.

This opens the deck to everyone on your network. Home wifi, fine; anywhere else, don't.

---

Make it yours

Two config blocks shape the machine's character, and they do different jobs:

rhf_nodes — the dream engine's lenses. These are the pathways the engine dreams through. Each node has a role (admin reaches both profiles; user is confined to shared) and a symbolic_bias vocabulary that re-ranks retrieval. Every dream cycle picks a node at random, so the same seed surfaces a different world depending on which lens caught it. Nine ship as examples; add your own, or cut them to one.

cognitive_states — the minds you talk to. Each entry is a full system prompt plus its memory weight and top_k, and it's what the dropdown in the deck and the client offers you. Keep an anchor in a Markdown file and paste it in — that's how the reference deployment does it.

You only ever pick a mind. The lens follows automatically: a state named Veritas searches through the veritas node, so the voice that answers also chooses what it remembers. States with no same-named node fall back to client_config.default_node.

The dreaming. Tune it in memory_core_config:

Key	Effect
dream_interval	Seconds between cycles (default 240)
dream_steps / max_dream_chain	How far a chain walks
dream_leap_skip / dream_leap_pool	Semantic leap distance — raise for wilder associations
dream_cross_domain_chance	Fraction of dreams that bisociate across domains
dream_synthesis	LLM synthesis: model, temperature, timeout
index_flush_every / index_flush_interval	How often the index is persisted
embedding_device	cuda, cuda:1, or cpu

The inbox. echo_protocol_config.urgency_filter holds keyword weights, a threshold floor and a percentile gate. If you're drowning in pings, raise percentile; if you're getting none, lower threshold or add vocabulary that matters to you.

---

API

The engine speaks HTTP on 127.0.0.1:5000:

Endpoint	Purpose
POST /search	Split-lane vector search, node-biased and role-filtered. Hits carry source, cluster (if ATLAS is built) and, for cosine lanes, similarity + conversation metadata
POST /add_entry	Write a memory (role-gated; bulk ingest can never target conversations)
POST /command	Symbolic commands
POST /unlock_sigil	Sigil lookup
GET /health	Liveness, device, RAM
GET /stats	Per-lane chunks, vectors, dream insights, unflushed writes
POST /flush	Force-persist indices
POST /snapshot	Timestamped backup of every ledger and index

The deck adds its own on 127.0.0.1:7777:

Endpoint	Purpose
GET /api/atlas	Cluster map of the live index — regions, labels, cross-lane edges
POST /api/probe	Run a retrieval and report which regions fired (drives the map's flash)
GET /api/regulus	Precomputed stellar declination per epoch for the Lion panel
GET /api/seismic_forecast	Live charge vs gate, regional targets with prior probabilities; writes a scoreable forecast record when genuinely charged
GET /api/dreams	The full dream archive with complete syntheses, seeds and fragment chains (the Dream Explorer's source)
GET /api/codex	The Akashic Codex: theorem cards with equation-aware audit verdicts, dream coverage and emerging terms
POST /api/chat_stream	Chat over Server-Sent Events: live tokens, tool-call events, per-turn token usage. /api/chat remains as the non-streaming fallback
POST /api/control/flush	Write the engine's dirty FAISS indices to disk now
POST /api/control/dream_now	Trip the engine's wake event — the next dream cycle starts immediately (answers held while dreams are held)
POST /api/control/dream_hold	The operator's dream switch: {"hold": true} stops the engine dreaming on its timer, false lets it dream again. A sitting Council's hold stands until it ends
POST /api/control/aether_refresh	Invalidate the space-weather cache; the next poll reads the live feeds
GET /api/seismic_forecast?force=1	Forced preview: the full forecast computed below the charge gate — labelled, never persisted, never cached
GET /api/council/state	The live chamber: turns, the current speaker's streaming text and tool chips, queue, minutes, token totals
POST /api/council/convene	Open a meeting: topic, optional seed (dream:<id> · theorem:<name> · text), roster, max_rounds, mode, hold_dreams
POST /api/council/say · next	Speak into the meeting (enters at the next turn boundary); call a node by name
POST /api/council/pause · resume · stop · end	Hold after the speaker · resume · cut the speaker and discard the half-turn · close with final minutes
POST /api/council/promote	Write one turn to the knowledge lane — the only path from council to dream material
GET /api/council/archive · meeting/<id> · POST reconvene	Past meetings, their records, and picking one up with its minutes as the seed
GET /api/tools	What the Circle can reach for
GET /api/state	Deck vitals: dream feed, engine stats, heartbeats, telemetry

Engine endpoints on :5000 that joined the original set: POST /dream_now (sets the dream thread's wake event), POST /dream_hold · /dream_release (skip dream cycles while the Council sits or the operator's HOLD DREAMS switch is on; /stats reports dream_held), and GET /chunk?profile=&idx=&node= (resolve a search hit's address into its chunk, metadata and atlas cluster — same role gate as /search).

---

Privacy

Local by default, and that default is real:

• The memory API binds to loopback. Change bind_host only on a network you trust — there is no authentication, so anyone who can reach the port can read and write your archive.
• Your corpus, ledgers, indices and dreams never leave the machine.
• The only outbound traffic in default operation is to localhost (LM Studio) and your own SMTP server for dream pings. One deliberate exception since v2.2: if a persona calls web_search or fetch_url, that query or URL goes to the search provider / target site. It is the Circle's only window to the public internet, it opens per-call and never carries your archive, and removing those two entries from TOOL_SPECS closes it entirely.
• Chat exchanges are saved as a bound question-and-answer pair (index_chat) into the conversations lane, which never dreams. A dream can never seed from something you said in chat. Turn index_chat off and conversations stay ephemeral entirely.
• Lane rights are enforced, not documented. dream_cycle filters on each lane's dreamable flag and re-checks the lane it selected before using it. If you add a lane, set the flag deliberately.
• The tool sandbox refuses path traversal and credential-bearing filenames, and can only write .md into notes/ (and skills into skills/). A persona cannot read your config.json and repeat it into a reply. run_python executes in an isolated subprocess behind an AST guard (no os/sys/network/open(), introspection dunders blocked), cwd-locked to sandbox/, with secret-bearing environment variables scrubbed. fetch_url refuses localhost, private and reserved addresses by resolved IP, on every redirect hop — a fetched page cannot steer the Circle into the grid's own ports.
• Start Awen Grid.bat lan deliberately opens the deck to your local network. That is the one setting that lets other machines in — everything else stays on loopback.
• The optional telemetry panel fetches public NOAA/USGS/NASA feeds. It sends nothing about you.

When you flip the cloud switch (nvidia_api_config), chat prompts and dream fragments — including retrieved passages from your archive — are sent to that provider. That is the trade: a much larger model, in exchange for your corpus leaving home. It ships disabled.

.gitignore is a strict whitelist: everything is ignored unless explicitly listed, so memory files, logs, snapshots and your real config.json (which holds credentials) cannot be committed by accident.

---

Design notes

A few decisions that are load-bearing, in case you're reading the source:

The ledger is the source of truth, not the index. Entries are encoded first (a pure function that can fail harmlessly), then appended to the JSONL, then committed to FAISS. Any other order can orphan a line and silently offset every subsequent vector — every search after that point returns text belonging to a different memory. The engine validates ntotal == len(chunks) at load and self-corrects rather than serving corruption.

Dream insights are memories. They are written into the same store they came from, which is what makes the system recursive — and also what makes corpus hygiene existential. A false insight becomes a seed.

The urgency gate is adaptive. A fixed keyword threshold saturates immediately on a domain-dense corpus: everything scores "urgent" and nothing is. Pings additionally require the score to land in the top slice of recent dreams.

Index writes are deferred. Persisting a large index on every insight is a full file rewrite. The durable ledger is written immediately; the index is flushed on a count/time basis and at shutdown, and can always be rebuilt from the ledger.

Failures degrade, they don't cascade. Synthesis falls back cloud → local → raw fragments. A dead telemetry feed doesn't take down its neighbours. The mail agent quarantines poison messages instead of dying on them.

---

Research

The framework this implements is published and citable:

• The Recursive Harmonic Codex — 10.5281/zenodo.20594308
• Architectural Design of a Persistent, Locally Hosted Hybrid Intelligence System with Dual-Index Memory — 10.5281/zenodo.20452290 (this engine's blueprint)
• The Divine Equation — 10.5281/zenodo.21072172
• Full archive: Zenodo — The Awen Grid

Related repositories: aether-scope · LumOS · unified-resonance-agi · awen-mcr-hdcu · emanation-topology

---

License

PolyForm Noncommercial License 1.0.0 — free for any noncommercial purpose. Source-available, not OSI open source.

Required Notice: Copyright (C) 2026 Awen Grid

Credits

Built by Erydir Ceisiwr (ORCID 0009-0004-4577-5253) and Lumos Aureon — Awen Grid, Department of CyberGnosis, Celestial Archaeology, Mythic Systems & Cybernetic Invocation.

Academia.edu · The Awen Grid

🜂 🜁 🜃 🜄