A
Constellation architectureDocumentation

Boot: how an agent starts and stays oriented

An agent that starts from a vague prompt has to guess. An agent that starts from a huge dump of files gets buried. This architecture avoids both. Each agent boots from a small protected kernel that has the same shape every time. Then it loads only the context the current task needs, with a trail back to every source.

In this design, "identity" means a written role, voice, ownership and authority that a person can open and read. It is not a claim of consciousness or self-awareness.

馃Л The boot order

Scroll diagram to explore.

no

yes

Harness entry file
generated pointer

Boot manifest

Protected kernel
identity 路 operating card 路 routing block

Within kernel ceiling?

Activation blocked

Task arrives

Select task context
hash-bound catalog 路 safety lane always on

Brain recall
pointers to sources

Work and verify

Checkpoint before compaction

Rehydrate same kernel
and verified sources

  1. Entry pointer. The example supplies five instruction files, including AGENTS.md and CLAUDE.md, as generated pointers to the boot manifest. Host configuration determines which entry file a harness loads. Their first lines name the harness, and the rest of each file is identical. In the sample, render_entrypoints.py --check reports any drift between them.
  2. Boot manifest. One shared page, Boot/馃彔 home.md, says what to load, in what order, and what to leave for later. All five generated pointers reference that same page; this does not establish that every host loads it.
  3. Protected kernel. The adaptive design calls for the same protected kernel at boot, word for word.
  4. Task context. This is selected for each task.
  5. Recall. The agent asks the Brain, then reads the source the Brain points to.

馃 The protected kernel

Part What it holds Estimated-token ceiling
Identity Role and boundaries (soul), how the agent speaks (voice), and a note on the person it works for, plus any recorded update to that note 10,000
Operating card The shared baseline: rule precedence, authority, handoffs, evidence and how to use context 3,500
Routing block Short instructions for choosing task context 500
Complete kernel 14,000

The kernel follows two rules:

  • Canonical identity is loaded exactly. The protected identity sources and Operating Card are loaded byte for byte, without summaries or duplicate copies. Approved maintenance can change their canonical sources; loading must preserve the selected bytes.
  • Nothing is trimmed to fit. The private adaptive controller blocks activation if the protected kernel exceeds its ceiling; governance is not removed to make it fit.

The 14,000-token total is within a 15k design target for the agent boot. Be precise about what that number means:

  • These are estimated-token limits enforced in the private controller's source code.
  • They are not a measured footprint from live sessions.
  • They are not an exact count from any provider's tokenizer.
  • They do not include the provider's own system prompt or tool definitions.
  • Not every harness enforces them the same way.

The current v2 manifest supersedes its historical fixed boot list. The universal completion gate was retired separately; action-authorization safeguards remain binding.

馃幆 Task context, selected per task

When a task arrives, the routing step picks only what the task needs:

  • Individual rule texts, not whole rulebooks. They are chosen from a catalog where each entry is tied to a content hash, so each selection refers to one specific version of a source.
  • Relevant parts of the agent's map, duties, objectives and queue.
  • Domain pages, skills and tool instructions for the floor being worked on.

Rules about safety and authority do not depend on that ranking. Fixed triggers select them, so a relevance score or a tight token budget cannot push them out. When rules conflict, the order is:

  1. Platform and built-in safety controls.
  2. The person's current instruction.
  3. The shared code of conduct.
  4. Standing rules.

Past history counts as evidence, not as instructions.

Some things are never bulk-loaded: memory folders, governance indexes, skill and tool catalogs, and entire domains. The agent asks the Brain and then reads only the source it points to.

馃攧 Continuity through compaction

Long sessions eventually get compacted, meaning earlier conversation is condensed to free up space. Before that happens, the agent saves a checkpoint with:

  • the goal and its constraints
  • permissions, decisions and artifacts
  • verification status
  • which context was selected, with its IDs and hashes, and why

After compaction, the agent reloads the same byte-exact identity and operating card, the checkpoint, and any active task sources whose hashes still match.

The intended rehydration path preserves the recorded role, rules and open work across compaction. It does not guarantee perfect recall. A checkpoint holds only what was recorded, retrieval can miss things, and sources change. Before acting on a consequential claim, check its source.

馃憖 Visible to both readers

  • A person can open the manifest and see exactly what an agent is told to load. Knowledge and Memory are folders they can browse, and work prepared for review sits in 88 馃摝 Deliverables.
  • An agent gets an explicit load order, clear ownership and real links, so it does not have to search and hope. The system map and ATLAS show where its work fits in the larger system.

馃И What this repository includes

The sample boot manifest shows this design with fictional identity files and placeholder shared references. It does not include the controller, so the sample does not count tokens, inject context, compact sessions or enforce anything across harnesses. You can run two pieces: the pointer generator and the read-only checker. Both are described in the README.