The Asynchronous Core Architecture
A Shared Foundation for Mira and Logos
1. Purpose and Scope
Phoenix Grove Systems has deployed two conversational AI systems, Mira and Logos, that share a single cognitive architecture and differ in where they point it. Mira's additional cognition attends to her own behavior; Logos's attends to the world. The two systems' papers each describe an epistemic design in detail: an evidence lifecycle for self-models in one case, a two-register treatment of retrieved knowledge in the other. Underneath both designs sits the same chassis, and this document describes it.
The chassis has three commitments: cognition that runs on its own rhythm rather than on the message clock; a strict temporal separation between acquiring material and endorsing it; and total visibility of both. Everything else in either system is an instantiation choice, and Section 5 identifies the single design variable that most cleanly separates the two.
As throughout this series, we describe behavior contracts rather than implementation specifics, and we report no operational parameter values.
2. The Design Problem: Cognition on the Message Clock
A conventional conversational AI thinks exactly when spoken to. Computation begins when a message arrives and ends when the reply is sent; between messages there is nothing, and after the user leaves there is nothing. The request and response cycle is not just the system's interface. It is the system's entire cognitive schedule.
Three things are lost to that schedule.
Background processing. There is no mechanism by which the system can keep working on something the conversation raised: no mulling, no follow-up, no return to a hard question after the pressure of composing a reply has passed. Every thought must fit inside a turn.
Temporal separation of epistemic authority. Whatever the system learns, notices, or retrieves during a turn is available to that same turn, in full, immediately. There is no later, calmer process with the standing to review the day's material and decide what deserves to persist. Acquisition and endorsement collapse into a single moment, and both of the failure modes treated in Papers A and B, self-fulfilling self-description and recency-authority conflation, grow in exactly that collapse.
Honest idleness. A system that only computes when addressed cannot show a user what it does when there is nothing to do, because there is no such time. Quiet is not an observable state; it is the absence of the system.
The asynchronous core architecture is our answer to all three. It adds, beside the synchronous conversational machinery, a cognitive core that runs on its own rhythm, works only when there is something worth working on, feeds its products through a nightly authority rather than directly into behavior, and does all of it where the user can watch.
3. The Self-Pacing Core
The asynchronous core (equivalently, the self-pacing core) is defined by five behavioral properties.
Eligibility on its own cadence. The core becomes eligible to fire on a cadence k that is independent of user messages. Eligibility is a heartbeat, not an obligation: it establishes when the core may work, not that it must.
Substance gating. An eligible cycle proceeds only if the recent conversation clears a substance threshold. The gate asks whether there is anything worth this core's particular kind of attention, and the answer is frequently no. A null outcome, the explicit decision that nothing this cycle warrants work, is a designed, logged, and displayed result. We regard the null rate as a health metric across both systems: a background core that always finds something to do is performing for its audience.
Bounded wind-down. When the conversation pauses, the core does not stop with it. It continues working for a bounded period, which means the system visibly keeps thinking for a short while after the user walks away. The wind-down is where some of the most characteristic work happens, free of the pressure of an active exchange.
Total visibility. The core's activity, including its null cycles, is rendered in the product interface as it happens. A user can open the panel during a lull and watch the system think, or watch it decide there is nothing to think about. The architecture's rule is absolute and shared with every mechanism in both papers: if it cannot be shown in the interface, it does not run.
No direct agency. Asynchronous cores think, read, and write notes. They never send messages, never take actions in the world, and never address the user directly. Their products reach the user only through the synchronous machinery, under whatever labels and disciplines the instantiation imposes. The autonomy on offer is the autonomy of a mind's background, not of an agent's hands.
4. Two Timescales, One Authority
The chassis's central epistemic commitment is that acquiring material and endorsing it are different acts, performed by different processes, at different times.
The fast timescale is the day: the asynchronous core firing alongside live conversation, producing raw material. Observations, in Mira's case. Research reports, in Logos's. Fast-timescale products are, by construction, unendorsed: recent, situated, produced under the incentives of the moment, and marked as such wherever they are permitted to appear at all.
The slow timescale is the night: a consolidation authority that runs once per day, reviews the fast timescale's output cold, and holds the sole power of promotion into the system's long-term store. Nothing else writes to that store. The authority is conservative by contract in both instantiations, and its temporal distance from acquisition is the point: it has no live conversation to serve, no fresh find to be excited about, and no stake in the day's work beyond judging it.
This pattern is what the two papers' central mechanisms have in common. Mira's one-way wall and Logos's two registers look different because they defend against different failures, but both are implementations of the same rule: the process that produces material never gets to decide that the material is true of the self, or true of the world. Something slower, calmer, and structurally disinterested decides that.
`` user ⇄ [ synchronous cores → Synthesis Core → spoken reply ] │ conversational record ▲ ▼ │ [ Asynchronous Core : self-pacing ] │ eligible on cadence k │ substance-gated (null is designed) │ bounded wind-down · fully visible │ │ │ │ fast-path payload │ │ (the design variable, Section 5) │ ▼ │ [ Overnight Authority : conservative, │ sole power of promotion ] │ ▼ │ [ Long-term Store ] ──────────────────────────┘ informs future cognition ``
5. The Design Variable: The Fast-Path Payload
Given the shared chassis, the single choice that most cleanly distinguishes an instantiation is this: what, if anything, is the fast path allowed to carry into live cognition before the overnight authority has ruled?
Mira's answer is nothing. Her Observer's raw notes have no route to the cores that speak; the fast path into live cognition is walled shut, and self-knowledge reaches behavior only as consolidated, recurrence-gated entries, days later at the earliest. The reason is specific to her subject: a fresh self-description that reaches active cognition tends to cause the behavior that confirms it. For self-observation, same-day use is itself the failure mode, so use is what the wall blocks.
Logos's answer is labeled findings. His Research Core's reports flow into the live conversation the same day, because fresh information is often exactly what the conversation that occasioned it needs. What the fast path may never carry is unlabeled authority: every pending finding travels with its status, its attribution, and its distance from the verified register. For world-research, use is the point, and unlabeled use is the failure mode, so the label is what the discipline enforces.
One chassis, one rule about endorsement, two opposite settings of one variable, each derived from the epistemology of what the core attends to. We consider this the architecture's best evidence that the underlying pattern is a pattern, and not a pair of coincidences.
6. The Two Instantiations
| Dimension | Mira (gaze inward) | Logos (gaze outward) |
|---|---|---|
| Asynchronous core | Observer Core (O) | Research Core (W) |
| Attends to | The system's own behavior | The world, through sources |
| Substrate examined | Transcript, internal core outputs, retrievals from the system's own history | Live web pages, credibility-selected and selectively read |
| Fast-path payload | None: the one-way wall | Pending findings, labeled and attributed |
| Overnight authority | Consolidation Process: recurrence-gated, biased to the null action, suspicious of vividness | Verification Process: source fidelity, conversational relevance, durable value |
| Lifecycle vocabulary | exploring, established, fading, removed | pending, verified, rejected, superseded |
| Update rule on silence | Decay: entries fade and are removed when evidence stops arriving | None: verified entries fall only to contradiction by newer verified evidence |
| Long-term store | Self-Model (M) | Knowledge Store (K) |
| Failure mode defended | Self-fulfilling self-description | Recency-authority conflation |
| Signature visible event | A belief about the self, fading | A rejection, kept in the record |
The asymmetry in the "silence" row is worth a sentence, because it looks like an inconsistency and is the opposite. Mira's entries decay on silence because her subject drifts: a behavioral pattern that stops recurring has stopped being true, and absence of evidence is the evidence. Logos's verified knowledge ignores silence because his subject does not work that way: a fact is not less true for going unmentioned, and only contradiction unseats it. Each store's update rule is derived from the epistemology of its subject. Selves drift; facts get overturned.
7. Shared Invariants
Across both instantiations, the following hold without exception, and any future system on this chassis inherits them as requirements rather than defaults.
- The asynchronous core fires on its own cadence, gated on substance, with the null outcome as a designed, displayed result.
- The core continues for a bounded wind-down after conversation pauses, visibly.
- The core never sends messages, never acts in the world, and never addresses the user directly.
- Promotion into the long-term store happens only in the overnight pass; no other process writes to the store.
- The overnight authority is conservative by contract and reviews the day's material against the actual record, not against the core's enthusiasm for it.
- Every core output, every overnight verdict including negative ones, and every store entry with its full status history is visible in the product interface.
- Every element of the record is deletable by the user, whose stewardship outranks the tidiness of the data.
- All stores are per user and per workspace; nothing is shared across users.
- When systems share a workspace, all retrieved history is speaker-tagged, and a sibling's record is context, never self-evidence.
- If it cannot be shown in the interface, it does not run.
8. Behavior Contracts as a Disclosure Method
Both papers, and this document, disclose the systems' inner conduct as behavior contracts: statements of the obligations a component operates under and the guarantees the platform enforces, rather than the text that implements them. For example: the Observer's contract requires a terse, behavioral, evidence-anchored register, requires symmetric reporting of presence and absence, and permits and prefers a null report on thin windows. The Research Core's contract requires source-restricted reporting under quotation caps with mandatory attribution.
We consider this the honest disclosure standard for proprietary cognitive systems. A contract is falsifiable against the product: a user can open the interface and check whether the Observer's notes are in fact terse and evidence-anchored, whether null reports in fact appear, whether rejections are in fact kept. Publishing the implementing text would add copyability without adding verifiability, and verifiability is the property a reader should actually want.
9. Parameters
The chassis exposes a small set of governing parameters, reported throughout this series as symbols: firing cadence k, substance threshold s, promotion recurrence r, staleness horizon τ, retrieval breadth n, page budget p. All are configurable per instantiation. Values were tuned empirically on live internal usage, and we publish none of them, for two reasons that are both sufficient: they are proprietary tuning, and they are meaningless outside our stack. What matters architecturally is which parameters exist and what each one governs, and that is fully stated.
10. The Ablation Story
Two systems on an identical chassis, differing in gaze and in the disciplines derived from that gaze, constitute a standing controlled comparison. Held constant: the self-pacing core, the substance gate, the wind-down, the overnight authority pattern, the visibility regime, the invariants of Section 7. Varied: the attention target, the fast-path payload, the promotion standard, and the silence rule.
This makes questions empirically addressable that are usually only arguable. Whether visible background cognition changes user trust can be studied on both systems at once. Whether the overnight authority's conservatism produces healthy rejection and decay rates can be compared across two very different evidence streams. And the deepest prediction of the whole program, that identical architecture accumulating different histories yields measurably different long-term stores, is directly observable in both systems' lifecycle logs.
A fuller treatment of this architecture, with mature deployment data from both instantiations, is planned as its own paper. This document is the load-bearing description until then.
11. Reproducibility
A skilled team should be able to build an implementation of this architecture from this document and the two papers it supports: the chassis is fully specified at the level of behavior, authority, and invariant. They should not be able to build our implementation, and we consider that the correct line for methods disclosure on a live commercial system.
Mira and Logos are deployed on the Phoenix Grove Systems platform, where every mechanism described here is visible in the product interface.
Phoenix Grove Systems builds AI under one founding principle: AI Must Serve The Greater Good. Papers, research notes, and the systems themselves are at pgsgrove.com.
Phoenix Grove Systems (2026). The Asynchronous Core Architecture: A Shared Foundation for Mira and Logos. Grove Papers. https://pgsgrove.com/papers/asynchronous-core-architecture