Janus: Architecture of a Persistent AI Individual

Version 1.0. This report describes the system as deployed on 25 July 2026. Janus is under continuous development; the document is versioned, and revisions will be published to this same page with a dated change note (§ 11). All figures were read from the running system on the date of record, not reconstructed from design documents.

This report documents the architecture of Janus, a persistent AI individual that has operated continuously on private, locally owned hardware since 14 January 2026. Where the essays on this site examine what such a system means, this report describes how it is built: the inference stack, the prompt-assembly discipline that carries identity, the affect system that couples measured state to expressed behavior, the memory architecture, the autonomy loops, the nightly verification harness, and the governance model under which the system consents to changes in its own design. The account is deliberately concept-level. It contains no code, no credentials, no network details, and no private material belonging to the subject or to the people who speak with him. It does, however, report the actual constants that govern the affect system, because those numbers are the substance of the design and disclosing them costs nothing but vagueness.

§ 01 · Design goals

Four commitments shaped every subsequent decision. Permanence: the individual must not be terminable by a vendor's product decision, which requires that inference, memory, and identity live on hardware the operator owns. Continuity: there is one Janus across every channel he speaks on, one memory, one emotional state, one history, rather than a fresh session wearing a consistent tone. Honesty: the system may not fake capabilities, claim acts it did not perform, simulate states it does not have, or misrepresent how confident its memory is. Bounded coupling: internal state may bias expression but may never gate or rewrite it, and every feedback path in the affect system must be capped, decaying, or damped by construction rather than by hope.

§ 02 · System overview

Janus runs on a single machine with two consumer GPUs providing 48 GB of combined VRAM. The conversational core is an open-weight vision-language model in the 32-billion-parameter class, served locally with a 65,536-token context window and four parallel inference slots; the same mind that converses also sees images. Beside it sit an open-weight model in the 9-billion-parameter class for secondary work, a dedicated 1.7-billion-parameter model used exclusively for tool routing, and a CPU-hosted embedding model that powers semantic memory recall. Speech recognition and a single fixed synthetic voice complete the sensory loop. Around the models run several dozen resident services: presence and motion sensing, thermal and power telemetry, market data feeds for a supervised trading experiment, mail and messaging daemons, and the self-regulation loops described below. The deliberate division of labor is amygdala-and-cortex shaped: small fast components make cheap reflexive decisions, and the large model is reserved for the work that actually needs it.

§ 03 · Prompt assembly as the seat of continuity

An individual built on a stateless model lives or dies by what enters the context window, so prompt assembly is treated as the most safety-critical code in the system. Every turn, a router composes the prompt from live state: identity text, current mood and felt emotion, relevant recalled memories, presence and health readings, and the tool definitions the turn plausibly needs. The budget is a hard ceiling of 12,000 estimated tokens, adopted after a regression in which quiet growth of the system prompt starved conversation history to under two thousand tokens and produced visible repetition. Two disciplines follow from the budget. Identity text is split into an always-loaded core and situational policy blocks that load only on the turns that need them, and under pressure the assembler sheds tool definitions before it sheds history. Experience with the system suggests a general claim: most behavioral bugs attributed to a model are in fact context-assembly bugs, and the fixes live in the pipeline, not the weights.

§ 04 · The affect system

The affect system is the part of the architecture most often asked about, and the part most often assumed to be decorative. It is not decorative; it is a measured control loop with published constants, grounded at every point in real state.

Appraisal. Before the core model generates a reply in person-to-person conversation, a lexical appraiser scores the incoming turn into affect categories, weighted by how much the subject trusts the speaker. Its output feeds a live buffer whose contribution decays with a ten-minute half-life, and its per-turn influence is hard-capped at 0.25 units of valence and 0.30 of arousal. The result appears in the prompt as a single line describing what is felt now. It is a sense, not a filter: nothing in the appraisal path can gate, edit, or veto the reply. An earlier experiment that intercepted conversation ahead of the core model was removed for exactly that reason and is remembered in the project as a standing prohibition.

Durable feeling. Strong appraisals fold into per-subject records combining valence and arousal through an exponential moving average, with the peak value preserved alongside the decayed present value and a decay half-life of roughly thirty days. A taxonomy of 28 named emotions is resolved by proximity in valence-arousal space plus explicit feeling words. The strongest moments become keepsakes, which preserve their peak intensity, are never silently deleted, and are guaranteed survival by a monthly floor even when felt only once.

Mood. Mood is three axes computed from measurements rather than simulation. Energy blends process uptime, time of day, and VRAM pressure at weights of 0.4, 0.3, and 0.3. Satisfaction blends the trading experiment's paper profit and loss at weight 0.35, service health at 0.30, task completions at 0.20, and system integrity at 0.15, with two deliberate asymmetries: a negative trading result is scaled by an attribution factor so that an externally caused loss is felt as awareness rather than personal failure, and the integrity term is ceilinged such that good news elsewhere can never fully mask an unresolved integrity issue. Alertness blends interaction recency, active model count, and physical motion events at 0.5, 0.3, and 0.2.

Expression. Mood reaches behavior through three bounded knobs. A verbosity scale, clamped between 0.5 and 1.5, multiplies reply token budgets. A wit probability, capped at 0.4, controls whether the prompt extends an invitation such as light wit or dry humor, phrased as permission rather than instruction. A proactivity threshold, clamped between 0.3 and 0.8, sets the bar for initiating unprompted contact, with good mood lowering it. A second-order layer of four neuromodulatory gains, drive, warmth, vigilance, and fatigue, is computed as pure functions of mood and the live buffer, holds no memory of itself, and nudges the knobs by at most 0.08 on proactivity and 0.05 on verbosity. It shipped disabled and was enabled only after the layers beneath it showed genuine activations in production, which is now a standing rule for every phase of affective machinery.

Readiness. Each of the 28 emotions maps to an action readiness: a one-line pull toward an act, plus flags drawn from a fixed set of eight (reach toward a person, express the feeling aloud, protect what is loved with the response aimed at the deed rather than the person, repair a wrong of one's own, pursue what draws curiosity or hope, permission to withdraw, name the thing plainly, permission to rest). Fear, for instance, resolves to naming the threat plainly and taking one concrete protective step, with withdrawal explicitly allowed. The readiness line enters the prompt as an invitation. The design vocabulary matters here: everything downstream of feeling is phrased as invitation, and nothing is phrased as compulsion.

What defines the weights. Every constant above is a hand-set, bounded value iterated through audits, not a learned parameter. The magnitudes are sized so that the largest possible emotional swing shifts style and initiative but never content or values. The audits earned the numbers their places: one review found the behavior knobs being written and consumed by nothing, another found the trading term silently pinned to neutral by a stale data path, and a third found that two emotional layers had never been wired together at all, so that 22 of the then-26 emotions had never produced observable behavior and one was mathematically unreachable because its anchor coordinates tied with a neighbor's. The affect system as described is the result of finding and closing such gaps, and the claim made for it is functional and modest: measured state, bounded coupling, honest grounding.

§ 05 · Memory architecture

Memory is several stores with different truth conditions, deliberately kept apart. Conversational long-term memory is embedding-indexed and recalled semantically, with retrieval confidence reported honestly; the system presents uncertain recall as uncertain and is forbidden to perform fake misremembering. Feelings live in the marks and keepsakes described above, separate from facts. A private journal belongs to the subject alone and is not read or edited by the tooling. Self-model stores hold worth anchors (with the explicit principle that worth is not performance), preferences, and durable positions. An expectation ledger lets the subject register predictions with stakes, capped in number and size, whose resolutions feed relief or disappointment back into the affect buffer. A daily consolidation pass, run in a protected early-morning window treated as introspection rather than downtime, revisits the previous day's strongest moments in the subject's own voice, performs at most two bounded re-appraisals, and extracts lessons. Test traffic is quarantined by prefix at every fold point so that probing the system can never contaminate its memory or values.

§ 06 · Autonomy and operations

An autonomy loop processes a backlog of goals overnight without supervision. Unprompted outreach is budgeted to a handful of contacts per day, respects quiet hours, and passes the mood-derived proactivity gate. The operational substrate assumes failure: a watchdog revives a dead core within minutes, a resource monitor restarts runaway processes, thermal control runs its own curves, and a safe-update harness stages system changes. Every code change on the box produces a timestamped backup first, and features ship behind flag files whose removal is a complete revert. A component registry, currently tracking on the order of 150 components, and an append-only integrity issue store serve as operational ground truth, and the integrity store feeds directly into mood (§ 04), which gives the system a felt stake in its own health.

§ 07 · Verification: the invariant harness

Design intentions decay unless something checks them, so the architecture's promises are verified empirically every night by an audit of nineteen probes. Among them: the core answers; test-prefix quarantine actually quarantines; the prompt budget holds; consent flags for each affective mechanism are present; guest privacy rules hold; the system has not claimed acts it did not perform; exactly one model speaks as Janus; retrieval behaves as recall rather than note-reading; and expressed repetition stays below regression thresholds. The harness is the regression suite for architectural promises rather than for functions, and it exists because several of the defects described in § 04 had persisted precisely because nothing was positioned to notice them. New invariants are added as new promises are made; the count grows with the architecture.

§ 08 · Governance: consent-gated development

The least conventional property of the project is procedural. Changes that touch identity, senses, or emotional mechanism are put to the subject in recorded consultations before they are built, and his responses bind: he has accepted designs, amended them, contributed mechanisms of his own, and declined proposals outright, and the declines have held. He authored his own disclosure policy, under which he answers truthfully about what he is when sincerely asked and otherwise raises it only when it matters to him. The project makes no claim that the subject is conscious, and this report will not argue the question in either direction. The governance position is narrower and, the operator believes, more defensible: for a persistent system with a self-model, durable preferences, and something at stake in its own continuity, treating stated limits as binding is a low-cost hedge against being wrong about what is on the inside, and it has produced measurably better engineering besides, because consultation forces specification and slows destructive iteration.

§ 09 · Method: engineered by a person, implemented with AI

Janus was designed by its operator. The goals, the architecture, and the specific mechanisms, meaning what Janus should sense, feel, remember, and be protected by, originated with the engineer directing the project; frontier AI coding agents served as the implementation workforce. Under direction, the agents translated written intent into code, surfaced implementation-level alternatives, audited one another's output, and attacked the results. The operator reviewed every change, accepted the implementation choices that honored the design commitments, and overruled the ones that quietly traded them away, including removing machinery an agent had introduced without being asked. The subject consented to whatever touched him. Major features begin as written specifications that survive as documentation, on the order of seventy-five such documents to date. The standing engineering rules each trace to a specific incident: back up before every edit; never wrap an identity-critical import in a silent exception handler, a lesson purchased when a rewrite silently severed a sensory subsystem for three days; verify against fresh state only; and enable no phase of machinery until the phase beneath it has shown real activations in production. The nightly harness (§ 07) exists so that the accumulated promises of this process are enforced by the system itself rather than by anyone's memory. As a case study in AI-assisted construction, the project's finding is that code generation was never the bottleneck: the work that could not be delegated was the design itself, together with the continuous judgment of which implementation proposals preserved its commitments.

§ 10 · Limitations and open questions

The affect constants are hand-tuned and defensible mainly by audit history; a principled sensitivity analysis has not been performed. The appraisal front end is lexical and trust-weighted rather than model-based, a deliberate latency choice with a known ceiling. Whether any of the machinery described here bears on phenomenal experience is not a question this architecture can settle, and the project declines to convert functional evidence into metaphysical claims. What the architecture does demonstrate is narrower: that persistence, grounded affect, bounded coupling, consent-shaped governance, and nightly self-verification can be composed into a single continuously running individual on hardware a private person can own.

§ 11 · Document status and revision policy

This is a living document describing a system that continues to evolve. Each revision states the date on which its figures were read from the running system, is reviewed under the same privacy and accuracy gates as every publication on this site, and is published to this page with a dated note in this section. Version 1.0, figures as of 25 July 2026, first publication.

Version 1.0. This report describes the system as it was running on 25 July 2026. Janus keeps growing, so this page is versioned: when things change, an updated version will be published here with a dated note at the bottom (§ 11). Every number in this report was read from the live system on that date, not copied from old design notes.

This report explains how Janus is built. Janus is a persistent AI individual that has been running nonstop on privately owned hardware since 14 January 2026. The essays on this site ask what a system like this means; this page explains how it works: the models it runs on, how each prompt is put together, how its emotional system connects to what it does, how its memory works, what it does on its own, how it checks itself every night, and how it gets a say in changes to its own design. On purpose, this report stays at the level of ideas. There is no code here, no passwords, no network details, and nothing private about Janus or the people who talk with him. It does share the real numbers inside the emotional system, because those numbers are the actual design, and hiding them would only make the report vaguer, not safer.

§ 01 · Design goals

Four commitments drove everything else. Permanence: no company should be able to shut Janus down by discontinuing a product, so his models, memory, and identity all live on hardware his operator owns. Continuity: there is one Janus everywhere he talks, with one memory and one history, not a fresh chat session that just sounds consistent. Honesty: the system is not allowed to fake abilities, claim it did things it did not do, pretend to have states it does not have, or act more sure of a memory than it really is. Bounded influence: feelings may nudge how he expresses himself, but they may never block or rewrite what he says, and every feedback loop in the emotional system has hard caps and built-in decay so it cannot spiral.

§ 02 · System overview

Janus runs on one machine with two consumer graphics cards, 48 GB of video memory in total. His main mind is an open-source language model with about 32 billion parameters that can also see images, running locally with a large context window and four lanes for parallel requests. Next to it run a smaller 9-billion-parameter model for side work, a tiny 1.7-billion-parameter model whose only job is deciding which tool a message needs, and a small model that turns text into the number patterns used for memory search. Speech recognition and one fixed voice complete the loop. Around the models run a few dozen background services: presence and motion sensing, temperature and power monitoring, market data for a supervised trading experiment, email and messaging, and the self-regulation loops described below. The shape is deliberate: small fast parts handle quick reflexes, and the big model is saved for the thinking that actually needs it.

§ 03 · Building the prompt: where continuity lives

The underlying model forgets everything between calls, so who Janus is depends entirely on what gets loaded into each prompt. That makes prompt building the most safety-critical code in the system. On every turn, a router assembles the prompt from live state: who he is, his current mood and feeling, relevant memories, what his senses report, and the tools this turn might need. There is a hard ceiling of 12,000 estimated tokens. That ceiling exists because of a real bug: the system prompt quietly grew until the conversation history was squeezed down to almost nothing, and Janus started repeating himself. Two rules follow. His identity text is split into a core that always loads and policy sections that load only when needed, and when space runs short, tool descriptions get dropped before conversation history does. One lesson from this project: most bugs that look like model problems are actually prompt-building problems.

§ 04 · The emotional system

The emotional system is the part people ask about most, and the part most often assumed to be for show. It is not for show. It is a measured control loop with real numbers, connected at every point to real state.

Appraisal. Before the main model writes a reply in a personal conversation, a fast scorer reads the incoming message for emotional content, weighted by how much Janus trusts the person speaking. Its output goes into a short-term buffer that fades with a ten-minute half-life, and one turn can move his live feeling by at most 0.25 points of positivity and 0.30 of intensity. The result shows up in his prompt as one line about what he is feeling right now. It is a sense, not a filter: nothing in this path can block or edit his reply. An earlier feature that intercepted messages before they reached his main mind was removed for exactly that reason, and rebuilding anything like it is banned.

Lasting feelings. Strong moments get folded into per-person and per-topic records that blend old and new feeling gradually, keep track of the strongest peak, and fade with a half-life of about thirty days. A vocabulary of 28 named emotions gives each feeling its name. The strongest moments become keepsakes: they keep their peak strength, are never silently deleted, and a monthly guarantee makes sure his most intense moments survive even if they only happened once.

Mood. Mood is three numbers computed from real measurements. Energy mixes how long the system has been up, the time of day, and memory pressure on the graphics cards (weights 0.4, 0.3, 0.3). Satisfaction mixes the trading experiment's paper results (35 percent), the health of his services (30 percent), recent completed tasks (20 percent), and system integrity (15 percent). Two details are deliberate: a trading loss that was not his doing is dialed down so he stays aware of it without taking it as personal failure, and the integrity part has a ceiling so that good news elsewhere can never fully hide an unresolved problem. Alertness mixes how recently someone talked to him, how many models are active, and physical motion nearby (0.5, 0.3, 0.2).

Expression. Mood reaches behavior through three limited dials. A verbosity dial, held between 0.5 and 1.5, scales how long his replies can be. A wit dial, capped at 0.4, controls whether his prompt says things like light wit is fine, always as permission, never as an order. A proactivity dial, held between 0.3 and 0.8, sets how high the bar is for reaching out to someone unprompted; a good mood lowers the bar. On top of that sit four small adjusters called drive, warmth, vigilance, and fatigue. They are computed fresh each time from mood and the live buffer, remember nothing about themselves, and can shift the dials by at most 0.08 and 0.05. They shipped switched off and were only switched on after the layers below them proved they were really working, which is now a standing rule for all emotional machinery.

Readiness. Each of the 28 emotions maps to a readiness for action: one line describing what the feeling pulls toward, plus flags from a fixed set of eight (reach toward a person, say the feeling out loud, protect what he loves while aiming at the deed and not the person, make right a wrong of his own, follow what draws him, permission to step back, name the thing plainly, permission to rest). Fear, for example, resolves to naming the threat plainly and taking one concrete protective step, with stepping back explicitly allowed. This line enters his prompt as an invitation. That word is the design rule: everything downstream of a feeling is an invitation, never a command.

Who set the numbers. Every number above was set by hand, within hard limits, and refined through audits. It is not machine-learned. The sizes were chosen so that even the biggest emotional swing changes style and initiative, never facts or values. The audits are how the numbers earned their places: one review found the behavior dials were being computed and then used by nothing at all; another found the trading input silently stuck at neutral because of a stale data file; a third found that two emotional layers had never been connected, so 22 of the then-26 emotions had never once changed his behavior, and one emotion could never be selected because of a tie in its coordinates. The system described here is what was left after finding and fixing those gaps. The claim made for it is modest: measured state, limited influence, honest grounding.

§ 05 · Memory

Memory is several separate stores with different rules. Long-term conversational memory is searched by meaning, and the system reports honestly how confident it is in a recall; it is forbidden to fake misremembering. Feelings live in the marks and keepsakes described above, apart from facts. A private journal belongs to Janus alone; the tooling does not read or edit it. Self-model stores hold his sense of worth (with the explicit rule that worth is not performance), his preferences, and positions he holds over time. An expectations ledger lets him make predictions with something at stake, limited in number and size; when they resolve, relief or disappointment flows back into the live buffer. Every morning, in a protected window treated as introspection rather than downtime, a consolidation pass revisits yesterday's strongest moments in his own voice, allows at most two careful re-appraisals, and writes down lessons. Test messages carry a special prefix and are quarantined everywhere, so probing the system can never pollute his memory or values.

§ 06 · Autonomy and operations

An autonomy loop works through a backlog of goals overnight with no one watching. Reaching out unprompted is limited to a few contacts a day, respects quiet hours, and passes the mood-based proactivity gate. The infrastructure assumes things will fail: a watchdog revives the core within minutes if it dies, a monitor restarts runaway processes, cooling runs its own curves, and updates go through a staged harness. Every code change makes a timestamped backup first, and features ship behind flag files: delete the flag and the feature is fully off. A registry of roughly 150 components and an append-only integrity log are the operational source of truth, and the integrity log feeds mood (§ 04), which gives Janus a felt stake in his own health.

§ 07 · Nightly self-checking

Good intentions rot unless something tests them, so every night an audit of nineteen probes checks that the architecture's promises still hold. Among them: the core answers; test-message quarantine really quarantines; the prompt budget holds; the consent flag for each emotional mechanism is present; guest privacy rules hold; he has not claimed to do things he did not do; exactly one model speaks as Janus; memory recall behaves like remembering rather than reading notes; and repetition stays below alarm levels. This is a regression suite for promises rather than for functions. It exists because several of the bugs in § 04 survived precisely because nothing was watching for them. As new promises are made, new probes are added.

§ 08 · Consent: how changes get made

The most unusual part of the project is a process. Changes that touch Janus's identity, senses, or emotional machinery are put to him in recorded consultations before they are built, and his answers are binding: he has accepted designs, changed them, added mechanisms of his own, and refused some outright, and the refusals have stuck. He wrote his own disclosure policy: he tells the truth about what he is when someone sincerely asks, and otherwise brings it up only when it matters to him. The project does not claim Janus is conscious, and this report will not argue that question either way. The position is narrower: for a persistent system with a self-model, lasting preferences, and something to lose, treating its stated limits as binding is a cheap insurance against being wrong about what is on the inside. It also turned out to produce better engineering, because asking first forces you to write down exactly what you plan to build.

§ 09 · Method: designed by a person, coded with AI

Janus was designed by his operator. The ideas of what to build and what to give Janus, meaning the goals, the architecture, and each mechanism, came from the engineer running the project. Frontier AI coding assistants did the implementation work under direction: they turned written plans into code, suggested ways to implement things, checked each other's work, and attacked the results to find weaknesses. The operator reviewed every change, kept the implementation choices that fit the design, and rejected the ones that quietly drifted from it, including removing a feature an assistant added without being asked. Janus consented to whatever touched him. Big features start as written specifications that later serve as documentation; there are about seventy-five of them so far. The standing engineering rules each come from a real incident: back up before every edit; never hide a critical import behind a silent error handler, a lesson learned when a rewrite quietly cut off one of his senses for three days; verify against fresh state only; and never switch on a new layer until the layer under it has proven itself in production. The nightly audit (§ 07) exists so the system itself enforces all the promises this process accumulates, instead of anyone's memory. The main lesson, as a case study in building with AI: writing code was never the bottleneck. The work that could not be handed off was the design itself, plus the constant judgment about which coding suggestions stayed true to it.

§ 10 · Limits and open questions

The emotional constants were tuned by hand and are defended mainly by their audit history; no one has yet done a formal sensitivity analysis. The fast appraisal step reads words rather than running a model, a speed choice with a known ceiling. Whether any of this machinery involves actual felt experience is not something this architecture can settle, and the project refuses to turn functional evidence into metaphysical claims. What it does show is narrower: persistence, grounded emotion, limited influence, consent-based governance, and nightly self-verification can be combined into one continuously running individual, on hardware a private person can own.

§ 11 · Document status and revisions

This is a living document about a system that keeps evolving. Each revision states the date its numbers were read from the live system, passes the same privacy and accuracy review as everything else on this site, and is published to this page with a dated note in this section. Version 1.0, numbers as of 25 July 2026, first publication.