Browse all nodes

Every node in this graph. 104 nodes across 10 form types.

Entries marked ⊕ were grafted from a donor graph; the marker links to the donor's source for that node.

By form type

Each form type has its own index page listing nodes of that form with their summaries. Use this when you want to drill into a specific form.

• Contracts (13) — Form specifications — thin compliance rules with RFC 2119 keywords.
• Decisions (1) — Recorded choices with Why, Alternatives Considered, and What Would Change It.
• Convictions (14) — Normative stances the project holds about how to work.
• Aspirations (2) — Directional targets with acknowledged gaps and recognition criteria.
• Observations (24) — Descriptive claims with epistemic grounds (Empirical, Retrospective, Contested).
• Predicates (17) — Typed edges with Carries, Crescent-per-neighbor, and Typing sections.
• Glosses (5) — Interpretive definitions that frame concepts through a broader lens.
• References (19) — External sources the graph draws on, with publication metadata.
• Skills (8) — Agent-invocable workflows with numbered steps, grounded in the Decisions they enforce.
• Touch Points (1) — Guided introductions that frame a reader's lens onto a region of the graph — not summaries.

All nodes alphabetically (104)

Every node in one list, sorted by title. Each entry shows its form type so you can tell what kind of node it is. Use this when you remember a name but not the form, or when you want to scan the whole graph at once.

• A Cached Snapshot Read Diverges From the Live Shared Log — Observation — When a reader caches its own copy of a chat room's message log and a further message then posts, the cached snapshot disagrees with the live shared log
• A Cross-User Notification Fires Within the Posting Write's Atomic Envelope and Rolls Back With It — Observation — Posting a chat message that mentions a user fires a registered post-timing observer synchronously, inside the same set_property that records the message; the mentioned user's tr...
• A Lost Update Appears Only Without the Runtime's Serialization of Concurrent Writes — Observation — When two writers each compute a new member list from the same snapshot captured before either committed, the second write overwrites the first and one writer's update is lost
• A Merry Source Calling a Sandbox-Denied Kfun Errors on First Fire — Observation — A Merry reaction whose source calls write_file
• A Merry-Compiled Room Reaction Executes Within the Sandbox Surface — Observation — A Merry script compiled at runtime from a source string, bound on a chat-room object as a per-room reaction property, and fired via run_merry executes against the room's propert...
• A Model-Authored Merry Tool Body Compiles, Runs Sandboxed, and Writes Back to Live State — Observation — A language model, given a compact Merry syntax primer, authors a tool body as literal source text in one exchange; the source is admitted through the Merry parse, bound on the r...
• A Non-Atomic Cross-Agent Property Write Leaves Partial State on Error — Observation — When the same two-room writer is run through a non-atomic batch and throws after the first write, the first room's append survives while the second room is never written
• A Property Change Fires No Reaction Where No Observer Is Registered — Observation — Posting a chat message that mentions a user on a room with no mention-notify observer registered fires no cross-user reaction; the mentioned user's tracker stays empty even thou...
• A Recursion Killed Mid-Flight Resumes From an Interval Snapshot and Delivers Its Result — Observation — A recursive task tree with a pending scheduled step, its runtime killed with SIGKILL and no orchestrated dump, restores from the last interval snapshot; the surviving call_out f...
• A Regular User Cannot Kick from a Chat Room — Observation — A chat-room admin verb that calls a private capability-check helper before any state mutation rejects the call when the actor's chat-user.admin-tokens list contains no token mat...
• A-MEM Agentic Memory (Xu et al., 2025) — Reference — A-MEM proposes agentic memory for LLM agents organized as a Zettelkasten-inspired interconnected knowledge network with dynamic indexing and linking, achieving 85-93 percent tok...
• Agent Code Containment Stacks Five Axes, Not One — Conviction — Code an agent runs on the eOS runtime platform sits inside five independent containment mechanisms
• Agent Harnesses Drive the Runtime, Not the Reverse — Conviction — The agent harness uses the runtime as a tool
• Agent Infrastructure Rests on Runtime Primitives — Aspiration — The directional target the eOS Continuum project works toward at the platform-purpose layer
• Agent Operations Commit Wholly or Roll Back Wholly — Conviction — Every agent operation on the runtime either commits all of its state changes or reverts the runtime's in-memory state to the pre-operation snapshot. Partial completion is not a...
• Agent Runtimes Require Native Primitives, Not External Glue — Conviction — The runtime-level guarantees agent infrastructure depends on
• An Admin-Capability-Holding User Can Kick from a Chat Room — Observation — A chat-room admin verb that calls a private capability-check helper before any state mutation accepts the call when the actor's chat-user.admin-tokens list contains a token whos...
• An Atomic Cross-Agent Property Write Either Commits Fully or Rolls Back Fully — Observation — When one operation appends a message to two separate rooms through the Merry batch surface in atomic mode, the two writes are a single all-or-nothing unit
• An atomic LPC Function Body Rolls Back on Deliberate Error in an HTTP-Dispatched Call — Observation — With the atomic modifier on an LPC function that mutates a counter and then errors, an HTTP-dispatched POST that triggers the function returns success while subsequent GETs obse...
• An LPC Function Without the atomic Modifier Does Not Roll Back on Caught Error — Observation — Two mechanism probes
• Aspiration Form Contract — Contract — A directional target the project works toward, carrying its acknowledged Gap, current Work, and Progress-Recognition markers ⊕
• assists_by — Predicate — Facilitation by agent or person ⊕
• Builders Own the Runtime Platform They Depend On — Aspiration — The directional target the eOS Continuum project works toward at the sovereignty layer
• built_on — Predicate — Foundational layer the subject rests on ⊕
• Capability Boundaries Are Runtime-Enforced, Not Policy-Checked — Conviction — The runtime platform enforces capability boundaries at the runtime level, not at the application policy layer. Each agent runs as a privileged identity the runtime checks on eve...
• Chat Room State Held Only In Memory Does Not Survive a Cold Boot Without a Snapshot — Observation — A chat session held in in-memory property-bearing objects
• Chat Room State Survives Statedump and Restore — Observation — A chat session established on an in-memory property-bearing room
• ChatTheatre Kernellib Carries Object Registry and Granular Resource Tracking Absent From Cloud-Server Kernel — Observation — Kernellib retains an object registry (objregd) and tracks callouts/events/editors as resources; cloud-server's kernel layer has neither
• Christopher Allen — Gloss — The principal author of this graph's content nodes
• ClawVM Harness-Managed Virtual Memory (Rafique and Bindschaedler, 2026) — Reference — ClawVM proposes harness-layer enforcement of atomicity, persistence, and capability boundaries for stateful tool-using LLM agents, arriving independently at the primitives-belon...
• Cloud Server (Croes, 2012, rev. 2026) — Reference — Felix Croes's canonical DGD application kernel
• Code Load Compiles Into the Live Runtime, Bounded by Capability Tiers — Conviction — The eOS runtime platform accepts new code into the running runtime as a runtime operation; what the loaded code can do is bounded by the capability layer rather than by pre-depl...
• composes_with — Predicate — Routinely used alongside ⊕
• Compound AI Systems Optimization Survey (Lee et al., 2025) — Reference — A survey of optimization methods, challenges, and future directions for compound AI systems
• conforms_to — Predicate — Compliance with a specification ⊕
• Console and Wire State Queries Read the Live State Graph, Not a Synthesized View — Observation — Operator console verbs and authenticated HTTP reads answer from the running platform's live state, and a just-committed mutation is visible to the very next query
• contends_with — Predicate — Open tension with adjacent concept ⊕
• Contract Form Contract — Contract — The meta-contract: how a Contract node in this project is named, structured, declares inheritance, and conforms to itself ⊕
• contrasts_with — Predicate — Adjacent concept occupying different territory ⊕
• Conviction Form Contract — Contract — A held normative stance the project asks contributors to share, carrying Why-It-Is-Held and Drift Recognition sections ⊕
• Decision Form Contract — Contract — A committed choice with Why, Alternatives Considered, and What Would Change It; situational rather than standing ⊕
• DeepContext.com Graph (Allen, 2026) — Reference — The seed Deep Context graph; donor of the meta-layer (Form Contracts, Predicates, generic graph-operation Skills) grafted into eOS-DeepContext at instantiation
• DSPy Compiling Declarative Language Model Calls (Khattab et al., 2023) — Reference — DSPy is the foundational paper for treating LM pipelines as text-transformation graphs
• Empirical Observation — Gloss — An Observation whose grounds name a specific measurement experiment or direct observation ⊕
• eOS Continuum Welcome — Touch Point — A guided introduction to the primitives-vs-glue diagnosis and the eight runtime primitives this graph anchors
• eOS-Harness Composes With Adjacent Tools, Not Against Them — Conviction — The eOS-Harness platform adds runtime-level primitives that current agent platforms rebuild from external glue; it does not replace the adjacent layers (LLM providers, vector st...
• eOS-Harness Is the Wrong Runtime Platform Without Platform-Pain — Conviction — The runtime platform eOS-Harness commits to carries real overhead; that overhead is justified only when the application's complexity comes from problems the platform's primitive...
• Event Notification Is Atomic With State Change, Not Polled or Queued — Conviction — The eOS runtime platform fires event notifications synchronously inside the atomic operation that caused the state change. Listeners observe the same atomic envelope as the chan...
• extends_contract — Predicate — Strict inheritance between form contracts ⊕
• frames_lens_on — Predicate — Frames a reader's lens onto a region of the graph ⊕
• Gloss Form Contract — Contract — An interpretive definition whose filename carries the working definition, usable from the filesystem without opening the file ⊕
• Graft — Gloss — A node copied from a donor graph into a recipient graph ⊕
• grafted_from — Predicate — Per-node content provenance from a donor graph ⊕
• Graph Audit — Skill — Sweeps the graph for drift across categories (vocabulary, ghost links, orphans, un-annotated edges, forbidden predicates, non-ASCII filenames); aggregates by pattern, not by file ⊕
• Graph Inception — Skill — Performs the local Open Integrity inception ceremony that stands up a new Deep Context graph with its own SSH-signed root commit and DID ⊕
• Graph Load Audit — Skill — Surveys the graph for node integration depth ⊕
• Graph Orient — Skill — Orients an agent to this graph at first entry by reading AGENTS.md, the landing page, then Contracts, Convictions, and Predicates in a prescribed order ⊕
• grounded_in — Predicate — Normative or structural foundation ⊕
• has_component — Predicate — Mereological relation where the subject contains the object as a component ⊕
• Hot Reload Is a Runtime Operation, Not a Deployment Event — Conviction — The runtime platform absorbs code updates as runtime operations rather than as deployment events. Logic updates land into the running runtime; in-flight operations finish with t...
• in_practice_domain — Predicate — Membership in a Practice Domain ⊕
• informed_by — Predicate — Weaker influence than grounded_in ⊕
• informs_downstream — Predicate — Providing foundation or evidence to a downstream node ⊕
• Inquiry Form Contract — Contract — A thesis-driven investigation node carrying a research question, current state, and open questions, with predicate vocabulary deferred to practice ⊕
• Markdown Node Contract — Contract — The base file-form every node inherits: encoding, filename rules, YAML scope, identity predicate block above the H1, Relations section, and named-edge syntax ⊕
• Mem0 Production Memory (Chhikara et al., 2025) — Reference — Mem0 is a production-oriented memory layer for AI agents using LLM calls to extract facts from conversations, storing them in hybrid vector and graph databases
• MemGPT Towards LLMs as Operating Systems (Packer et al., 2023) — Reference — MemGPT is the foundational paper framing agent memory as an OS-shaped concern, treating the LLM context window as physical memory and external storage as disk with virtual-memor...
• MemMachine Ground-Truth-Preserving Memory (Wang et al., 2026) — Reference — MemMachine stores raw conversational episodes and indexes them at sentence level, minimizing LLM dependence for routine memory operations and preserving factual integrity using...
• Memoria Modular Memory Framework (Sarin et al., 2025) — Reference — Memoria is a modular memory framework that augments LLM-based conversational systems with persistent, interpretable, and context-rich memory, integrating dynamic session-level s...
• Meriadoc (ChatTheatre, 2026) — Reference — The refererence implementation's sandboxed code-load DSL: source-as-property in the persistent image, multi-phase signal-triggered execution, decoration-and-compile over a denyl...
• Model-Harness-Fit (Bustamante, 2026) — Reference — Argues the matched pair of model and harness is the proper unit of analysis
• Multiple Agents See Coherent State Without User-Land Coordination — Conviction — The runtime platform guarantees that all agents see the same state at the same time. The runtime serializes concurrent operations on shared state; agents do not coordinate via l...
• Nine Fix Rounds Landed on One Live Composite Instance Without Restart or State Loss — Observation — During kernellib PR #129's development, nine interactive fix rounds
• Node Create — Skill — Authors a new node conforming to the form Contract it claims: filename pattern, identity predicate block, required body sections, annotated Relations edges ⊕
• Node Read — Skill — Reads a node progressively by layer (identity, H1, opening, Relations), letting an agent spend a finite context budget on the layer its task needs ⊕
• Node Validate — Skill — Verifies a single node against the Form Contract it conforms to, walking the inheritance chain and distinguishing mechanical violations from semantic ones ⊕
• Observation Form Contract — Contract — A descriptive claim with matched epistemic grounds (Empirical, Retrospective, Contested, On-Faith) and the conditions that would revise it ⊕
• One Observer on a Room Ancestor Fires for Every Room in the Cohort — Observation — When an append observer is registered once on a room ancestor and three child rooms set that ancestor as their ur-object, a message posting in each child resolves the ancestor's...
• Pattern Form Contract — Contract — A recurring craft move named from practice, with Heart at card scale, Problem, Forces, Solution, and Consequences ⊕
• Predicate Form Contract — Contract — A typed-edge definition with Carries, Crescent-per-adjacent-predicate, and Typing sections; a specialization of Gloss for predicate names ⊕
• Predicate Propose — Skill — Gates additions to the local predicate vocabulary; each new predicate arrives as a proposal with Carries, Crescent per neighbor, and Typing, not as drift discovered after the fact ⊕
• Recompiling an LPC File Over HTTP Updates the Next HTTP Response Without DGD Restart — Observation — A POST /compile of a new LPC source body for /usr/Test/hello changes the very next GET /greet response, with no DGD restart between the requests
• Recursive Language Models (Zhang et al., 2025) — Reference — Recursive Language Models treat the prompt as an external Python REPL environment the LM examines, decomposes, and recursively calls itself over
• Recursive Language Models Paradigm of 2026 (Prime Intellect, 2026) — Reference — A Prime Intellect blog post arguing RLMs are the paradigm of 2026
• Reference Form Contract — Contract — An external source pointer with an Adopted / Not adopted (yet) split and publication metadata; cite-by-wikilink rather than cite-by-URL ⊕
• responds_to — Predicate — Direct reply creating a conversation thread ⊕
• Retire Substrate Vocabulary; Adopt Runtime Platform — Decision — Replace "substrate" across the eOS-Harness graph and the eOS-kernellib doc set using a per-job mapping rather than a single global substitution. The term was carrying at least s...
• RLM Architectures Survey (Allen, 2026) — Reference — Seven RLM implementations surveyed from the RLM side outward
• Runtime State Is Persistent by Default, Not by Application Discipline — Conviction — The runtime platform carries persistence as a runtime primitive. Object lifetimes outlive any single process; the state graph survives restart without marshaling, save-this call...
• Runtime State Is Queryable Directly, Not Through a Synthesized API — Conviction — The eOS runtime platform exposes its own state to queries directly. Agents, humans, and other LLMs read what objects exist, what their state is, and what events have fired by qu...
• Runtime-Layer Compounding Overcomes Agent Harness Fit — Conviction — Held without separate inquiry
• scion_of — Predicate — Content lineage from a template graph ⊕
• Seed Stage — Gloss — The lifecycle stage of a newly authored node whose shape has not yet been tested against other nodes ⊕
• Self-Reflective Language Models (Alizadeh et al., 2026) — Reference — Self-Reflective Language Models extend RLM's recursive scheme with uncertainty-aware program-trajectory selection in the same Python REPL environment, achieving 22 percent accur...
• Skill Form Contract — Contract — An agent-invocable workflow as a compound-node graph node, carrying a runtime-invocation name, an Anthropic-spec description, and numbered steps ⊕
• source_voice — Predicate — Whose thinking is captured when different from the author ⊕
• Three Users in One Chat Room Observe Identical Message Order — Observation — When three users in one chat room each read the message log after a sequence of posts, all three reads return identical content in identical order
• Touch Point Form Contract — Contract — A guided introduction that frames a reader's lens onto a region of the graph ⊕
• Towards Resource-Efficient Compound AI Systems (Chaudhry et al., 2025) — Reference — Proposes a declarative workflow programming model and an adaptive runtime system for dynamic scheduling and resource-aware decision-making in compound AI systems
• Two Agents Contending for a Bounded Resource: Exactly One Claim Commits — Observation — When two users contend for the single open slot in a capacity-bounded chat room, the runtime serializes the two claim operations so exactly one commits and the other reads the p...
• Why Atomicity Matters to AI ML Infrastructure (Borrill, 2026) — Reference — A paper arguing atomicity must be explicitly constructed as protocol convergence in AI/ML training infrastructure rather than assumed as a temporal property
• Why I Built DSPy Agent Skills (codeandcontext.ai, 2025) — Reference — A blog post arguing that procedural knowledge differs fundamentally from raw information availability for agents, framing GEPA optimization plus RLM long context plus procedural...
• Without UrHierarchy-Inherited Observer Registration Each Chat Room Requires Its Own Observer Registration — Observation — When a chat room has neither its own observer nor an ancestor carrying one, a message posting in it finds no observer at any level of the ancestry walk and is recorded by nothing
• Working Draft — Gloss — The curation state of a node whose content is authored but not yet curated for cross-graph consistency ⊕