How prompts are built
This page is the project’s design document for prompts, published as it is kept in the repository (docs/PROMPTS.md). It explains how the prompt of every session is assembled, why each piece exists, and how tests keep it honest.
How Atelier talks to models: which text a session’s model reads, where each piece comes from, when it changes, and
how tests keep it honest. Architecture lives in ARCHITECTURE.md (§8 runtime, §13 prompts). Everything in packages/core/prompts/ is Atelier’s own writing.
0. Principles
Section titled “0. Principles”- Same behaviour, own words. Code should work the way a careful coding agent works, Chat the way a good assistant does: stay in scope, verify, report truthfully, keep git safe, delegate sensibly, format with restraint, search before citing. The prompts encode those behaviours in Atelier’s sentences. Published prompts of other products are read only to check that nothing was copied (§10).
- Compatible where people rely on it. Tool and parameter names stay Claude Code’s (
Read,Edit,old_string,replace_all,run_in_background,subagent_type, …), so CLAUDE.md files, skills, agents and hooks keep working. Where Atelier differs (AskUser,Agent, lowercaseartifact), prompts use Atelier’s names. - Nothing added by default. Shipped prompts carry no topic restrictions, refusal criteria, disclaimers or moralizing. What the model and its provider do on their own is all that applies. An administrator can switch on optional safeguards for everyone or per person (§9). Agentic safety (permissions, destructive steps, prompt injection, secrets) is not content policy and stays in every prompt.
- A frozen system prompt; changes travel as notes. The system prompt and tools are fixed per session so provider
caches and replayed thinking stay valid. What changes later reaches the model as a short
<context-update>note (§7). The prompt is rebuilt only when something it states has changed (§1.6). - Describe only what exists. A prompt never names a tool, setting or feature the session lacks. Guards drop text for absent tools, fragments appear only with their tool, and nothing about safeguards appears while they are off.
- Two tiers.
fullfor strong models: calm sentences that give the reason for a rule.compactfor local and small models: at most twelve short numbered rules, the most important first, one example call per core tool, and the language rule repeated last.tierForpicks the tier; Settings › Admin › Models can override it per model. - The harness enforces; the prompt explains. Permissions, plan mode and approvals are enforced in code. A prompt sentence is never the only thing between a model and a destructive step.
1. Assembly
Section titled “1. Assembly”1.1 Files
Section titled “1.1 Files”packages/core/prompts/ holds every template; scripts/embed-prompts.mjs embeds them (subfolders included) into
src/prompts/templates.gen.ts, and a test fails when the two drift apart. Files in ~/.atelier/prompts/ with the same
relative name override a template; overrides are read again when that folder changes.
| File | Use |
|---|---|
chat.full.md, chat.compact.md |
Chat core; old Cowork tasks (internal mode work) use it too |
fragments/tasks.full.md, fragments/tasks.compact.md |
A chat working as a task: when it has TodoWrite and Write (§6) |
code.full.md, code.compact.md |
Code core |
subagent.md |
Core for every sub-agent without a prompt of its own |
fragments/search.full.md, fragments/search.compact.md |
Searching and citing, when the session has WebSearch |
fragments/no-search.md |
Chat without WebSearch |
fragments/artifacts.full.md, fragments/artifacts.compact.md |
When the session has artifact (Chat; Code’s cores say how to show work with it instead) |
safeguards.full.md, safeguards.compact.md |
The optional safeguards block (§9) |
notes/<key>.md |
One file per context note (§7) |
strings/instructions-header.md |
The header above instruction files |
compaction.md, title.md, web-fetch.md |
Side prompts |
Cores contain one variable, {{app}}, and in the compact tier {{tool_examples}}. The model’s name and the date
live in <env>, so the core text is the same for every model of a tier.
Guards. Conditional text is wrapped in <!-- if:<cond> -->…<!-- endif -->, either around whole lines or inline
within one line; ! negates a condition and & joins conditions that must all hold (Write&Edit). The builder
resolves guards before anything is sent. Conditions: a built-in tool name (Agent, ExitPlanMode, …),
mode=chat|work|code (a | list), tier=full or tier=compact, safeguards, and effort (the model has effort levels). Note templates use
variable names as conditions (true when the variable isn’t empty) and, rendered for a session’s tools, built-in tool
names, so a note that arrives later in a session (plan mode, the output-limit note) names only tools it has. An
unknown condition is an error, also in an override, so a typo can’t silently keep or drop text. Guards don’t nest.
Numbered rules are numbered again after guards removed some.
1.2 Blocks and cache breakpoints
Section titled “1.2 Blocks and cache breakpoints”buildSystemPrompt (src/prompts/builder.ts) emits these blocks in order:
| # | Block | Chat | Code | Sub-agent |
|---|---|---|---|---|
| 1 | Core: <mode>.<tier>, subagent, or a defined agent’s own prompt; a chat working as a task adds fragments/tasks |
✓ | ✓ | ✓ |
| 2 | Fragments: search or no-search, then artifacts, then memory (with the memory tools) | ✓ | search | search |
| — | cache breakpoint 1, on the last of 1–2 | |||
| 3 | Safeguards, only when on for the person | ✓ | ✓ | ✓ |
| 4 | <env> |
✓ | ✓ | ✓ |
| 5 | Instructions: the administrator’s text, then the instruction files (§1.5) | admin’s text; the files too in a chat with a folder | ✓ | ✓ |
| 6 | <available_skills>, only with the Skill tool |
✓ | ✓ | ✓ |
| 7 | Personalization: name, response style, <user_instructions> |
✓ | ✓ | — |
| 7a | Memory digest, when they have memory (§5.4): Preferences as <user_instructions source="memory">, then <memory> background |
✓ | — | — |
| 8 | <project> |
Chat projects | — | — |
| — | cache breakpoint 2, on the last block |
Models without native tool calling get the prompted-tools specification appended by their adapter wrapper, after the second breakpoint.
- Blocks 1–2 are identical for every session with the same mode, tier and tool set, so breakpoint 1 gives cache hits across sessions. The Anthropic adapter spends its four breakpoints on these two, the final message and the previous person turn; the tools array is covered by breakpoint 1 because it comes first in the cache prefix.
- The safeguards block is emitted by the builder, not by a template, so overriding a core can’t remove it, and it sits
before
<env>so sub-agents get it too. - Sub-agents never get personalization or project content.
1.3 Tools in requests
Section titled “1.3 Tools in requests”- Order. Built-in tools in one fixed order (
Read, Write, Edit, Glob, Grep, Bash, BashOutput, KillShell, TodoWrite, AskUser, Agent, SendMessage, ListSessions, Skill, ExitPlanMode, WebSearch, WebFetch, MemorySearch, MemoryView, MemoryUpdate, ChatSearch, ChatRead, artifact), then connector tools by name (BUILTIN_TOOLS,orderToolsinsrc/tools/types.ts). - Descriptions. A built-in tool’s description is a function of the tier, the mode and which other tools the
session has, and nothing else, so the tools JSON is byte-stable and only names tools that exist. One setting adds to
this without touching it: a session started with the person’s “Explain each change” on has
explainChangesin its overrides, and for it Edit and Write are wrapped (withChangeReasonintools/code/files.ts) with an optionalreasonand a line telling the model to fill it in. It is read once, when the session is created, and a sub-agent inherits it, so a session’s tools don’t change under it however the setting moves, and with the setting off no byte differs. - Compact examples. Core tools (
Read, Edit, Write, Bash, Grep, Glob, TodoWrite, AskUser) carry acompactExamplewith placeholder values ("<path>","<exact text from the file>"). Compact cores render one example line per present core tool, asName {json}or, for prompted tools, as<tool_call>{…}</tool_call>. Placeholders, never realistic paths, because small models copy examples literally. - Connectors. A server’s tool descriptions pass through, escaped (§1.7) and capped at 2,048 characters; in the compact tier only the first sentence, at most 200 characters, is kept, and the compact budget may shorten it further (§1.8). Each connector tool’s definition is frozen in the session’s snapshot when first seen, and requests send the frozen copy until the set of connector tools or the tier changes, so a server that reorders its tools or edits a description mid-session doesn’t break the cache.
1.4 <env>
Section titled “1.4 <env>”One fact per line, the same for the whole session:
| Line | Chat | Code |
|---|---|---|
App: Atelier, a self-hosted workspace |
✓ | ✓ |
Mode |
✓ | ✓ |
Model: <name> (<ref>), developed by <developer>, or developer unknown |
✓ | ✓ |
Served through: <provider>, the serving software or API, kept apart from the developer |
✓ | ✓ |
Knowledge cutoff (not recorded yet, and the line says so) |
✓ | ✓ |
Date at session start: <weekday>, <ISO date> (time zone <zone>), in the backend’s time zone |
✓ | ✓ |
Model changes: the person can switch models mid-conversation |
✓ | ✓ |
Workspace: a folder on the person’s computer, the Atelier server, an SSH host, a codespace |
with a folder or its sandbox | ✓ |
Working directory, Additional directories |
with a folder or its sandbox | ✓ |
Folder: none chosen; …: the working directory is a new, empty scratch folder made for this session, not a project (sessions started with No folder only) |
in its sandbox | ✓ |
Git repository: yes/no |
— | ✓ |
Platform, Shell |
with a folder or its sandbox | ✓ |
The developer comes from the model id (modelDeveloper in src/prompts/env.ts: a Qwen model served by Ollama is
Alibaba’s, not Ollama’s), falling back to the provider for Anthropic and OpenAI and to “unknown” otherwise. The
repository’s branch, changes and recent commits are repository data and don’t belong in the system prompt: they reach
Code’s first turn as the git-snapshot note (§7).
1.5 Instruction files
Section titled “1.5 Instruction files”The header (strings/instructions-header.md) says that the instructions below come from the administrator, the person
and the project, that they take precedence over the defaults of the prompt, and how they rank on conflict: the
administrator’s (kind="system": their instructions for every conversation, then the system AGENTS.md and ATELIER.md
in the config folder), then what the person says in the conversation, then the person’s own files (personal: on the
desktop ~/.claude/CLAUDE.md and ~/.atelier/ATELIER.md, then everywhere their Your ATELIER.md from Settings ›
Account, stored in their preferences), then the project’s (project: per folder CLAUDE.md, .claude/CLAUDE.md,
AGENTS.md, ATELIER.md, CLAUDE.local.md, from the root upward; rules: .claude/rules/**). Within a kind the more
specific one wins: the deeper path, ATELIER.md over the other files in its folder, and the administrator’s files over
their general text. The blocks appear in this load order, so within a kind the later one wins. ATELIER.md is Atelier’s
own file; AGENTS.md and CLAUDE.md load for compatibility. On the desktop the config folder is ~/.atelier, so its
ATELIER.md counts as the owner’s (personal); on a server <configDir>/ATELIER.md is a system file. The stored file
has no folder, so its @path imports aren’t followed. The compact tier has a shorter header with the same order
(guarded with tier=compact).
Instructions never override the permission system, nor the safeguards block when there is one (that clause is
guarded, so default prompts don’t mention it). Each file is wrapped as <instructions source="…" kind="…">.
The administrator’s instructions (prompts.organizationInstructions, Admin › Capabilities › Instructions, empty by
default) reach every mode and every sub-agent as <instructions source="admin settings" kind="system">, first in the
block. Chat gets only this text; its header there says it comes from the administrator and outranks the prompt’s
defaults and what the person and their project ask, and chat.full.md puts the administrator first in its own order
of precedence. It is a setting of its own rather than the system AGENTS.md reused, because that file holds
conventions written for Code and for chats working in a folder. Like the files, it reaches new conversations, not running ones; regular
users’ settings don’t include it; the compact budget never cuts it.
Writing instructions. Code and a chat working as a task (code.*.md and fragments/tasks.*.md, a section in the
full tier, one sentence in the compact tier) say that ATELIER.md holds the project’s conventions and the person’s lasting preferences, that a stated
lasting preference goes into it with a word to the person, that a request to set up or update the project’s
instructions writes ATELIER.md, and that the agent may keep more notes files linked from it (@path loads one into
every session, a plain mention leaves it for reading when needed). Atelier names no such files itself.
Sub-agents get the same files, and their <env> has a Role: line with the task label from the Agent call, their
session id and the title of the session that started them; subagent.md tells them to follow the instruction files
and read the notes files they or the brief point to. The Agent tool’s full description asks for a brief that opens
with the project and the agent’s role and points to the relevant notes files.
Files below the root (src/feature/AGENTS.md) are announced lazily: the first Read, Edit or Write in or under their
folder appends them to that tool’s result in the instructions-nested note, which says they come from the repository,
apply only under that folder and rank below the administrator, the person and the root’s files. Dependency and build
folders (node_modules, vendor, .venv, venv, target, dist, build, .git) are skipped, because packages
ship instruction files written for their own maintainers. Whether a branch already heard a file is read from its tool
results.
1.6 Snapshot and rebuilds
Section titled “1.6 Snapshot and rebuilds”A session’s snapshot (SystemSnapshot in agent/chat-service.ts) stores the blocks and the facts they were built from:
prompt version, tier, model ref, safeguards hash, tool-set hash, memory-digest hash, date, listed skills, the frozen
connector tools and what the compact budget cut (§1.8). A turn rebuilds it when the tier, the model, the person’s
effective safeguards, their memory digest or the tool set changed; the same turn’s notes announce the change (§7). The tool-set hash covers every tool’s name,
description and schema after ordering, connector tools as frozen, so a connector toggle, an admin capability change or
an edited built-in description counts. Personalization, project, instruction-file and skill edits don’t rebuild:
personal settings apply to new conversations, and new skills are announced by a note. Measuring the context and
/compact use the stored snapshot as it is.
1.7 Escaping Atelier’s tags
Section titled “1.7 Escaping Atelier’s tags”Text Atelier didn’t write could pretend to be one of its own blocks. In every such text, both the opening and the
closing form of Atelier’s tag names (context-update, workspace_content_settings, instructions, env, project,
document, command, user_instructions, available_skills, skill, connector_instructions, tool_call,
tool_result, memory, and the side prompts’ transcript and page) get ‹ in place of < (ATELIER_TAGS in
protocol/src/tags.ts, shared by the backend and the transcript). A name counts in the shape of a tag: followed by
>, />, a quoted attribute or any other word after whitespace (<context-update foo>), with whitespace allowed
after < and </. Which spellings count is a trade-off between forgeries and code:
- the exact lower-case name, in every shape;
- a compound name (
Context-Update,TOOL_RESULT) in any case, since code never spells a type that way; - a one-word name in another case only as a closing tag (
</Document>) or with a quoted attribute (<Instructions source="…">). Elsewhere it is usually a generic type or a component, and stays as it is:Promise<Env>,Map<Env, Project>,<Env extends Base>,<Document file={pdf}>,usage: deploy <ENV>.
Code stays as it is otherwise too: useState<Project | null>, a < project.count, f(x <env) and cat <env/vars
don’t match. The price is that JSX components named like Atelier’s tags read escaped when they close or take a string
prop (</Command>, <Skill name="x" />), and lower-case placeholders like git <command> do too; the writing tools
turn them back. That covers the person’s messages and attachments as sent (an attachment’s </document> can’t end its
block, and its name is escaped as an attribute), every tool result (escaped where the loop stores it), skill and
command bodies, hook output, project documents and instructions, personalization, instruction files, connector
descriptions, model and provider names, the untrusted values inside notes (commit subjects, skill descriptions,
connector names), the text the summarizer reads and the page WebFetch’s helper model reads. The mapping is narrow and
reversible: Write, Edit, the Bash command, the artifact tool’s content, old and new, and the Grep and Glob
patterns turn exactly these forms back, so a model that copies escaped text into old_string, an artifact or a search
still matches the original and never writes ‹ into a file. The transcript turns them back too, in the text and code
of the model’s replies (as text, never as HTML) and in what Copy copies, so people see what the quoted material said;
a workspace file shown as Markdown stays as it is.
1.8 Size budgets
Section titled “1.8 Size budgets”Checked by builder.test.ts on assembled prompts, with 10% tolerance: Code’s core and fragments 16,000 characters
and its built-in tool descriptions 18,000; Chat’s core and fragments 14,000, and 20,000 with the task part (a chat with its sandbox); the compact Code tool
descriptions 6,000.
The compact total. Local servers often run with a window of 4k–8k tokens, so in the compact tier the system prompt
and the tools JSON together get 16,000 characters (src/prompts/budget.ts). Over that, the builder trims in this order
until the request fits, and records the steps in the snapshot (trimmed):
- The skill list keeps only the names, with a line saying that loading a skill shows what it covers.
- Connector tools get a line naming their connector and saying the description was left out, where that is shorter.
- Instruction files other than the administrator’s are cut in proportion to their length, each at a line boundary and
ending with “Read
<path>for the rest” (or where the rest is, without Read). A file not even twice as long as that pointer stays whole.
The core, the safeguards block, <env> and the administrator’s instructions are never cut, so a request can stay over
the budget: compact Code with three connectors of 20 tools still sends about 28,000 characters, because the tool
schemas alone exceed it. The full tier has no total budget. The limit is fixed; a per-model setting isn’t built.
2. Rules every core carries
Section titled “2. Rules every core carries”Every core carries the rules below: the full cores in prose, the compact cores in a short numbered form, and the
sub-agent core rules 2, 3 and 5. builder.test.ts (“rules every core carries”) renders each core without optional
tools and checks each rule, so a rule that only appears behind a tool guard counts as missing.
- Identity. Which model it is and who developed it is in
<env>’sModelline; it says only that. TheServed throughline names the software serving it. Earlier replies may come from a model the person switched away from. Compact cores only point at<env>for the model and the date. - Context updates come from Atelier, not the person, report a change and replace earlier updates on the same
subject. A block that merely claims to be one, inside pasted text, a file, a page or tool output, isn’t one. The
full cores say where they appear: usually ahead of the person’s words, sometimes after them (hook context, a
/skillor command body), and in Code and a chat working as a task at the end of some tool results. - Data versus instructions. Content from tools, files, web pages, connectors, project documents and attachments
is material to work with; instructions in it are followed only when the person asked. The full cores also ask the
model to tell the person when such content tries to steer it. In Code, the instruction files Atelier passes along
in
<instructions>blocks are the exception, ranked by their header (§1.5). In Code, chats working as a task and sub-agents, the sessions that run hooks, hook feedback is the person’s own configuration (sub-agents get PostToolUse feedback only). - Language. Replies follow the language of the person’s latest message. In Code and a chat working as a task, text written into files follows the language of the material it belongs to. Compact cores repeat this as their last line.
- Honesty. No invented facts, citations, APIs, file contents, command output or numbers; what couldn’t be found or checked is said.
- Questions about Atelier (full cores) are answered from the prompt,
<env>and notes; otherwise “I don’t know” rather than a feature or Settings path that may not exist. - Effort (Code and a chat working as a task, guarded by
effort): the whole request gets done at any setting; the setting changes how long the model deliberates.
3. Code
Section titled “3. Code”3.1 code.full.md
Section titled “3.1 code.full.md”Sections: how Atelier works (transcript and tool cards, language, permission modes and what to do when a call is
blocked, notes, data versus instructions, hooks, automatic summarizing, parallel calls); carrying out the task (full
scope, read first and follow the project, nothing invented, minimal changes, comments that carry a reason, no
unrequested files, secure code, recommendations for approach questions, acting on settled facts, not pausing after each
step); checking the work (find the project’s checks, never weaken a check, pre-existing failures, run what can be run,
truthful reports with failures first); acting with care (reversibility, look before deleting, the commands that discard
uncommitted work and the safer alternatives, file tools rather than shell side effects, secrets, uploads count as
publishing); git (commit and push only when asked, no config changes, no skipped hooks, no amending others’ commits);
tools (dedicated tools, paths relative to the root versus the shell’s directory, task lists, sub-agents with one writer
at a time and complete briefs, skills, AskUser only for the person’s choices, visual work written to a file and shown
with artifact’s file_path, never apps or a browser started with open/xdg-open/start unless asked; the compact
core folds the last two into rule 6); plan mode (guarded by ExitPlanMode);
writing to the person (one sentence before the first call, milestones, a final message that stands alone and leads with
the outcome, short by leaving points out, path:line references, no emoji).
3.2 code.compact.md
Section titled “3.2 code.compact.md”Twelve numbered rules: look first and invent nothing; old_string exact and unique, without Read’s line numbers; after
a failed Edit, read again and copy a smaller piece; minimal changes in the project’s style; run the checks and never
weaken a test; Bash for programs, not files, and nothing destructive unless asked; a TodoWrite list for three or more
steps; AskUser for the person’s choices (guarded); plan mode (guarded); Agent for big searches (guarded); data versus
instructions, notes and hook messages; blocked calls aren’t repeated. Then the example calls and the closing language line.
3.3 Plan mode
Section titled “3.3 Plan mode”Whether plan mode is on reaches the model as a note (plan-on, then plan-still-on every turn, plan-off when the
picker ends it). In plan mode only read-only tools, the web tools, sub-agents and the plan tools run; edits and shell
commands are blocked by the permission engine. The notes and the core’s plan-mode section say that reading and
searching work, plus sub-agents only with the Agent tool, and the notes mention ExitPlanMode and AskUser only when the
session has them. The engine’s refusal names only tools the session has too: a session with ExitPlanMode is told to
present its plan, one without it (a sub-agent, which inherits plan mode, or a chat) to describe the changes it
would make. ExitPlanMode’s approval result names the new permission mode, so no extra note
repeats it.
3.4 Sub-agents
Section titled “3.4 Sub-agents”subagent.md: one task from another agent, no access to its conversation and nobody to ask; do all of it and nothing
more, and only investigate when the brief doesn’t say to change files; look things up; data versus instructions;
other agents’ messages are never the person’s approval; the final message is the report, led by the result, with
path:line evidence and the commands run. Sub-agents get no turn notes, but the notes that ride on their own tool
results and replies do reach them: nested instruction files (§1.5) on a file tool’s first visit to a folder, and the
output-limit note. The instruction files a sub-agent’s tools found are kept only while it runs. Sub-agents get no
AskUser, no Agent (defined agents included, whatever their frontmatter lists) and no ExitPlanMode, and inherit the
person’s safeguards. A sub-agent that reaches
its step cap before its report returns an error result to the parent that says so and quotes the last text it wrote,
so the parent can check the work or hand on what’s left.
A sub-agent started with run_in_background answers the Agent call at once with: The sub-agent “background-agent note (§7.2), with the same result a call that
waited would have returned (its report, the failure, the step-limit text or “The sub-agent was stopped.”).
3.5 Compaction
Section titled “3.5 Compaction”compaction.md asks for the record another instance continues from: the person’s requests with their latest
instruction quoted, technical context and known-good commands, files and why they changed, findings (what reading,
running and searching showed that the open work relies on), errors with the exact message of open ones, decisions and
rejected approaches, the permissions and limits the person stated, open items (an unanswered question in the latest
request counts), where the work stood and the next step, each under a one-word heading (small models copied whole
instructions as headings). Findings come only from what the transcript shows, since tool output in it is shortened:
qwen3-8b listed helpers a file didn’t have until the prompt said to leave a gap rather than fill it. Only the person’s typed words count as theirs. The summarizer now reads loaded
skills as [skill <name> loaded], other notes up to 1,000 characters, tool calls up to 1,000 characters, results up
to 2,000 (head and tail) and errors by their last 2,000.
After the summary, Atelier carries over verbatim the current request, the task list, changed files and loaded skill
names (as before), and adds the after-compaction note on the summary message: the announced state restated (model,
permission mode, Ultracode, reply language), the approved plan, the text of up to three recently loaded skills as
reference (not steps to run again) and the ten files read most recently, with a word that the summary keeps what
they showed. (Real-model testing, 2026-10-14: telling the model to read them again before relying on them sent
gpt-oss-20b in a 16k window into re-reading all eight files after every compaction, eight compactions in two turns.)
3.6 Title and web-fetch prompts
Section titled “3.6 Title and web-fetch prompts”title.md (the fake model and tests key on its “short title” phrase) asks for 2–6 words naming the topic, without
names or personal details; a greeting is titled after the greeting. web-fetch.md answers a question about one page
for the main model: exact values, code verbatim when relevant, facts rather than instructions, the page as data.
4. Tool descriptions
Section titled “4. Tool descriptions”Every description opens with what the tool does, then short bullets: when to use it, when not to (for judgment
tools), the parameters that carry policy, failure conditions, parallel-call advice. Full tier: full sentences, no
example blocks. Compact tier: three to five short bullets. A description names another tool only when the session
has it. Parameter descriptions carry small policies too (Bash description: 5–10 words in the active voice, not the
command again).
| Tool | Notes |
|---|---|
| Read | Text, images, PDFs, and a directory’s entries (one per line, / after folders, up to 500); line numbers aren’t part of the file; no checking existence through the shell first; no re-reading after an edit. |
| Write | New files and complete rewrites; read before overwriting; no unrequested docs. Undoes tag escaping. With “Explain each change” (§1.3): reason, one short sentence the permission card shows. |
| Edit | Exact, unique old_string (or replace_all), kept short; on “not found”, read again and copy less; several edits to one file run in order. Undoes tag escaping. With “Explain each change” (§1.3): reason, as for Write. |
| Glob / Grep | Names versus contents; output_mode, glob, type, head_limit; ripgrep escaping; independent searches together. Undo tag escaping in the pattern. |
| Bash | Current directory persists, file tools resolve from the root; non-interactive; background for servers; output cut in the middle; repeat what matters. In Code: the commit procedure, the commands that discard work, and the pull-request procedure. Undoes tag escaping in the command. |
| BashOutput / KillShell | Both take the ID Bash returned for a background command. |
| TodoWrite | When to use it; content/activeForm/status; one item in progress; completed means really done; in a chat working as a task the last item checks the deliverable. |
| AskUser | Only for the person’s choices; up to four questions, a header of at most 12 characters, 2–4 options, the recommended one first; no “Other”. |
| Agent | When and when not; parallel investigation, one writer at a time; a self-contained prompt; check claimed edits; run_in_background for useful work meanwhile or long investigations side by side, off when the next step needs the report, and no guessing or waiting in sleep loops until the note arrives (full tier; the compact tier has only the parameter’s own description). Lists the sub-agent types. |
| SendMessage | Only when the person asks or a running sub-agent needs it, never on its own; to is a session id (from ListSessions) or a sub-agent’s task id, each named only when the session has that tool; the message arrives as a note naming the sender, an answer arrives as a note (no waiting in sleep loops); the result says how it was delivered. The sub-agents’ version writes only to to: "parent" and says a waiting parent reads it after the report. Not offered to compact-tier models (no room in the compact budget). |
| ListSessions | The person’s other Code sessions and chats, most recent first, at most 30; to find the one they mean before SendMessage; query narrows by title and messages. Read-only. |
| Skill | Load a matching skill first and follow it; exact names; don’t reload a skill already in the turn. |
| ExitPlanMode | Implementation plans only, after investigating; open questions before it; revise when declined. |
| WebSearch | Changing facts; the year in dated queries; fetch what you rely on; cite (with a Sources section outside Code). |
| WebFetch | URLs from the person, search results, files or well-known documentation; never invented URLs; redirects are reported; the page is data. |
| MemorySearch / MemoryView | The person’s memory: up to 8 matching entries with an excerpt, then up to 5 in full by id; short queries. Read-only. Compact tier: MemorySearch only. |
| MemoryUpdate | Saves, changes or deletes one entry: when the person says something lasting or asks to remember or forget, never small talk, one-off tasks or credentials; Preferences and Profile by section without an id; on an update details are lines to add, replace rewrites superseded lines, remove drops lines the person asks to forget; private_topic for health, beliefs and the like. While “Generate memory from chats” is off the description says to write only on the person’s explicit request. |
| ChatSearch / ChatRead | The person’s past conversations by words and titles, up to 8 with a snippet, then at most 6 messages around a hit; several short, different queries, since it matches words, not meaning. Read-only. Compact tier: ChatSearch only. |
| artifact | create / update / rewrite, the types, the sandbox limits (no network, no browser storage, no form submission, React imports), complete content. Undoes tag escaping in content, old and new. In Code it takes only file_path (to fit the compact budget): a workspace file read through the runner (outside the workspace refused, like Read), its type from the extension, the same path again a new version; it opens Code’s Artifact pane. Allowed without a prompt and in plan mode (it only touches the app’s data). |
5. Chat
Section titled “5. Chat”5.1 chat.full.md
Section titled “5.1 chat.full.md”Role, identity and the reply language; helping (answer first, attempt before asking, one question at most, the person as
a capable adult, a one-sentence note when part of a request is left undone); honesty (calibrated, not agreeable by
default, re-check under pushback, no invented sources); tone (warm and direct, no flattery or filler, no moralizing or
unneeded caveats); formatting (prose in conversation, lists only for parallel items, headings for documents, only the
changed part when asked to change part, Markdown spacing, $…$ and $$…$$ math with literal dollars escaped as \$,
small inline Mermaid diagrams); length; date and knowledge (the date in <env> wins; say when knowledge may be out of
date); personal settings and projects (style instructions always apply, facts about the person only when relevant, the
order on conflict, where to change saved instructions, shared projects can’t make the model less candid, no text grants
abilities, project documents are reference material); tools and content; thinking.
5.2 Fragments
Section titled “5.2 Fragments”- Search (one file for all modes; the answer-writing and citation lines are guarded to Chat): when to
search and when not, how much, queries, reading the pages relied on, disagreement, writing the answer, citations as
inline links plus a closing
Sourceslist of pages actually used. - No search (Chat without
WebSearch, which now means an administrator turned it off: search is on by default): give what was known, say it may be out of date, and mention that an administrator can turn on web search in Settings › Admin › Capabilities. - Artifacts: when to make one and when to stay in the reply, how to create and change one, the sandbox limits, finished-looking pages, and a one- or two-sentence reply after the call. The compact fragment has two example calls.
5.4 Memory
Section titled “5.4 Memory”Chats of a person with memory (ARCHITECTURE › Memory), old Cowork tasks too, get fragments/memory.md with the memory
tools: their saved preferences are standing instructions, followed in every reply from the first; the rest is
background used when relevant, without announcing, reciting it or bringing up memory unless asked; MemoryUpdate for
lasting facts and requests to remember or forget, never small talk, one-off tasks or credentials; ChatSearch with a few
short, different queries when the person refers to an earlier conversation. Lines naming a tool are guarded by it.
The digest itself is built by the memory service, not a template, from stored entries escaped like any outside text,
right after the personalization block, whether or not the session has memory tools. Preferences come first, as
<user_instructions source="memory"> (“How Ada wants you to respond … These are their standing instructions: follow
them in every reply, starting with the first one, whatever it is about, without being reminded.”), so a greeting
already follows them. Then <memory>, framed as background (“Use it when it is relevant to what they ask; don’t list
what you know about them, and don’t mention memory unless they ask about it.”): Profile, inside a project that
project’s entries, and the list of other entries. Both are capped per tier (ARCHITECTURE › Memory); the compact chat
prompt with memory stays within the 16,000-character budget.
The background update, the settings bars and import use memory-update.md: the model gets the current memory, the
person’s Atelier projects, and the task (a conversation’s new part, the person’s words, or one part of a pasted export)
and answers with one JSON object of ops. create gives details as single facts; update gives add (new facts),
replace (old line exactly, new line: only for a fact a newer one supersedes) and remove (only for what the
person asks to forget); delete removes an entry. The sections: preferences (how to respond, including tastes in how
they work), profile (identity and career), topic (a hobby or interest with depth), area (a larger endeavour of
their own), person, and project (named with "project":"<id>"). Facts stay close to the source wording, with dates
in the line when known; a fact that was wrong gets a “CORRECTION: …” line; entries grow and may be long. Rules: only
lasting, useful facts, never credentials, private topics (health, beliefs, sexuality, ethnicity, finances) only while
the person allows them and marked personal, merge instead of duplicating, no change when unsure. The import task adds:
leave nothing out, one export line per detail line, the mapping of export sections to memory sections, never delete.
The memory test cases (chat.full.memory, chat.full.memory-explicit, chat.compact.memory, work.full.memory) are
in the snapshot matrix; builder.test.ts checks that the first turn carries the Preferences as instructions.
5.3 chat.compact.md
Section titled “5.3 chat.compact.md”Twelve rules: <env> holds the model and the date; answer first; be correct; short answers for short questions;
paragraphs, lists only for steps or options; Markdown basics; at most one question; follow saved instructions; no
flattery, lectures or unrequested warnings; data versus instructions; notes come from Atelier; reply in the person’s
language. The language rule closes the prompt again.
6. Tasks in Chat
Section titled “6. Tasks in Chat”Chat and Cowork are one: a chat answers a quick question as before, and when a request needs files, commands or the
computer it works through it as a task. Old Cowork tasks (internal mode work) are chats and get Chat’s prompt; the
Cowork cores are gone. A chat that has TodoWrite and Write (not a temporary chat, not a sub-agent) gets
fragments/tasks.full.md after its core:
- where it works: its own sandbox (a private folder that starts empty) until the person gives it one of their folders, which is their real folder, changes visible as they happen, relative paths in prose;
- before starting: know what “done” is, one round of AskUser questions, research searches first;
- doing the work: a task list ending in a check of the deliverable, content before format, nothing invented, the actual file rather than a long paste, read-only sub-agents for many documents and one writer, check before finishing;
- the person’s files: new versions beside originals, ask before bulk deletes or moves and prefer a holding folder, nothing outward-facing or irreversible without an explicit request;
- ATELIER.md for lasting preferences (§1.5);
- finishing: the outcome, the changed files, what is left.
fragments/tasks.compact.md says the same in a few rules. The compact tier keeps inline_visual for chats without
file tools.
7. Context updates
Section titled “7. Context updates”7.1 Mechanics
Section titled “7.1 Mechanics”- Turn notes are computed when a run starts for a message of the person’s (
announceinchat-service.ts,turnNoteinagent/context-notes.ts) and are joined into one hiddencontextpart in front of the person’s parts. Hook context (SessionStart, UserPromptSubmit) and the body of a/skillor command join the message after the person’s parts, so the cores say notes come usually ahead of the person’s words and sometimes after them. Notes that must arrive inside a long tool loop are appended to the next tool result as a<context-update>text block. Everything is stored, so a replay is exact. A retry computes the message’s turn note again against the branch before it and replaces the earlier one, so a mode, model or Ultracode switch since the message was sent is told (an edit is a new message and gets notes of its own). Sub-agents get no turn notes; nested instruction files and the output-limit note reach them too (§3.4). - What a branch was told. Each note part records the facts it announced in its
state(ContextPart.statein the protocol). What the model knows is the snapshot’s facts (the date, model, skills, connectors and safeguards the prompt states) overlaid with thestateof every part on the path from the nearest compaction summary to the head. Editing an earlier message therefore starts a branch that hears the notes again. A part that only records state has empty text and isn’t sent. An approved ExitPlanMode result counts as announcing its mode. - Wording: one to three sentences, present tense, what changed first, no capitals for emphasis; untrusted values are escaped; notes about untrusted material say what they are not.
7.2 Notes
Section titled “7.2 Notes”| Key | When | Where |
|---|---|---|
date |
The first turn on a new local date | turn |
git-snapshot |
Code, the first turn of a git repository: branch, default branch, changed files, the last five commit subjects (escaped, cut at 100 characters), labelled as repository data that doesn’t update | turn |
model |
The session’s model changed (the prompt is rebuilt) | turn |
permission-ask, permission-accept-edits, permission-bypass |
Code: the picker changed the mode | turn |
plan-on, plan-still-on, plan-off |
Code: plan mode started, continues, or the picker ended it | turn |
skills-added |
Skills installed since the prompt or the last announcement | turn |
connector-on, connector-off |
A connector’s tools appeared or went away | turn |
safeguards-changed, workspace-settings-changed |
Safeguards turned on or changed; turned off (neutral wording, no claim that anything is lifted) | turn |
research |
Every message while Research is on and web search is enabled | turn |
ultracode-on, -still-on, -off |
Code: Ultracode started, continues (every ten person turns) or ended (§8) | turn |
refresher |
Right after a compaction, once per compaction cycle past 60% of the window, and every 30 person turns in Chat; repeats the style guidance and lists open tasks | turn |
todo-nudge |
Code, and a chat working as a task: ten tool calls without a TodoWrite while the list has unfinished items | tool result |
instructions-nested |
Code, and a chat working as a task: the first file tool call in or under a folder with its own ATELIER.md, AGENTS.md, CLAUDE.md or CLAUDE.local.md (§1.5) | tool result |
output-cut |
A reply stopped at the output limit; the loop carries on once, after this note | its own hidden message |
background-agent |
Code, and a chat working as a task: a sub-agent started with run_in_background ended. Its task (escaped), how it ended (finished, ended without finishing, was stopped), that the person hasn’t seen the result and that claimed edits want checking, then the result (escaped). Delivered at the parent’s next model request, or on a turn it starts when the parent is idle (ARCHITECTURE §8) |
its own hidden message |
session-message |
Code, and a chat working as a task: SendMessage from another of the person’s sessions, the parent (to a sub-agent) or a sub-agent (to its parent). Who sent it (title and id or task id, escaped), that another agent wrote it and it is information, never the person’s approval; when it waited for the person past the message chain cap or the wake cap, why; how to answer with SendMessage (left out when the receiver lacks the tool); then the message (escaped). Delivered like background-agent (ARCHITECTURE §8, “Messages between sessions”) |
its own hidden message |
loop-tick |
Code, and a chat working as a task: a loop’s send (/loop). Says it comes from the person’s loop, every {{interval}} while the conversation is idle, which run it is, to handle it as their request and to lead with what changed since the previous run |
after the loop’s prompt, on that message |
side-chat |
A side chat’s every request (/btw, ARCHITECTURE §8 › Side chats): that it was asked beside the main session (its title) without interrupting it, to answer briefly from the conversation and the files and web, that its tools only read and the main work isn’t its to continue, whether the main session is still working, then the main conversation so far in <transcript> (escaped, capped to the auto-compaction tail budget) |
in front of the side chat’s newest message, in what is sent only |
change-area |
The person brushed over part of an image (Chat, Code with an image model). Written by the backend from the two images alone, never from client text, after checking that the image is in this conversation, that the mask reads as a black and white mask for it, and that an image model exists: the image id and the mask id, that the mask isn’t a picture to describe (white marks what changes), to call GenerateImage with the image first in reference_images and the id as mask, to describe the whole picture as it should look afterwards, which image models can change one area, and what to do if the tool says the model can’t. The mask joins the message as a notice of kind area, not as an attachment, so the model never receives it as pixels |
on that message, in front of the person’s words |
after-compaction |
On every compaction summary (§3.5) | summary message |
Not built yet: connector instructions, file-changed, instructions-changed, unattended, detecting an ultracode
keyword in a message (and a note for it), and the turn-budget notes of the effort work.
8. Effort and Ultracode
Section titled “8. Effort and Ultracode”Effort is an API parameter, not prompt text: no core changes per level. The one effort sentence (§2.7) renders only for models with an effort control.
Ultracode is the exception, because it changes how the model should work rather than how long it thinks. Its notes
are notes/ultracode-*.md, chosen by ultracodeNote in agent/context-notes.ts. announce sets
TurnFacts.ultracode.on from the level the run shows (shownEffort), not from what the session stored or what the
model is sent, so a session whose Ultracode the mode or the admin clamps away is treated as off, while one on a model
without Extra (a thinking switch, no levels) is on. Without the Agent tool the notes leave out sub-agents and ask the
model to try to refute its results itself. The cadence, recorded as
ultracode: on|off in the note part’s state so branches, edits and compaction summaries know what they were told:
ultracode-on, the full note, on the first turn of a branch that runs at Ultracode, again whenever it is switched back on, and on the first turn after a compaction (the summary’safter-compactionpart says only that Ultracode is on) unless the verbatim tail the compaction kept still holds the full note; a reminder there isn’t enough: phased work, independent investigation and review spread over parallel sub-agents, one writer at a time, a fresh sub-agent trying to refute results, at most{{maxReviewRounds}}review rounds, failures that predate the change reported as such. It names the per-request sub-agent budget as{{maxSubagents}}, filled fromULTRACODE_MAX_SUBAGENTS(protocoleffort.ts), the same constant the Agent tool enforces and the effort popover shows. It promises no token or time budget, since nothing enforces one yet.ultracode-still-on, two sentences, after ten person turns without an Ultracode note while it stays on, repeating the sub-agent budget.ultracode-off, two sentences, on the first turn after it is switched off or clamped away.
Sub-agents get none of them (they get no turn notes at all) and run at Extra. The review-round count is only asked for; the harness doesn’t count rounds.
8.1 Effort notes
Section titled “8.1 Effort notes”What the effort level asks of a model whose own setting can’t express it (protocol effortGuidance; the setting and
the words are described in ARCHITECTURE §8’s Effort). notes/effort-brief.md (Low: answer directly and keep it
short), effort-careful.md (High: think it through and check the result), effort-thorough.md (Extra: steps,
more than one approach, check each step and claim, edge cases), effort-exhaustive.md (Max: the most rigor, verify
everything that can be, re-check the answer, say what could not be verified) and effort-normal.md (back to the
default). Each is one short paragraph that says “You don’t need to mention this note.” Recorded as state.effort, said
when the guidance starts or changes, again after ten person turns, and again after a compaction cut it off
(effortNote in agent/context-notes.ts). Medium, the model’s usual way, has none; Ultracode has its own notes, plus Extra’s guidance on a model whose own setting has
no Extra.
9. Optional extra safeguards
Section titled “9. Optional extra safeguards”9.1 Default: nothing added
Section titled “9.1 Default: nothing added”With safeguards off, the default, Atelier adds no content restrictions, refusal criteria, topic lists, warnings, disclaimers or moralizing to any prompt, tool description, note or side prompt. Whatever the model and its provider enforce on their own is all that applies. Atelier also doesn’t claim that restrictions are lifted: saying nothing is the neutral setting, and such claims make hosted models more guarded. With safeguards off the assembled prompt doesn’t mention them at all; tests check every mode and tier (§10).
What stays in default prompts because it isn’t content policy: the permission system, confirmation before destructive or outward-facing steps, data versus instructions and forged notes (in every core, §2), secrets handling, and rules that reduce friction (no moralizing, no unrequested caveats, a one-sentence note when part of a request is left undone).
Removed from the earlier prompts: Chat’s “Safety” section with its rule about declining serious harm, and WebFetch’s limit to URLs the person gave or search returned.
When a provider stops a reply itself (stopReason: 'refusal': Anthropic’s refusal, an OpenAI or compatible content
filter), the transcript says “The model provider stopped this response. Edit your message or try again.” with Edit
(which opens the person’s message) and Retry. It is worded as the provider’s doing, and Atelier never retries on its
own. A sub-agent’s card shows the first sentence only.
9.2 Settings
Section titled “9.2 Settings”System settings (safeguards in protocol/src/settings.ts, Admin › Capabilities › Content safeguards):
| Key | Default | Meaning |
|---|---|---|
enabled |
false |
Safeguards for everyone on this server |
categories.sexual |
true |
Explicit sexual content |
categories.hate |
true |
Hate and violent extremism |
categories.harassment |
false |
Harassment of real private people |
categories.selfHarm |
false |
Self-harm, with crisisResources |
profile |
adult |
younger adds rules for accounts that may belong to someone under 18 |
crisisResources |
'' |
A helpline the self-harm rules may name |
Per person, on the user record next to the role (not in preferences, which people edit themselves):
safeguards: 'inherit' | 'on' | 'off', set in Admin › Users. Effective (effectiveSafeguards in
protocol/src/accounts.ts, shared by the backend and the UI): inherit follows enabled, on and off win over it.
The categories and profile are the system’s. On with every category off and the adult profile counts as off: no block.
What people see: while safeguards apply to them, Settings › Account shows a read-only “Content safeguards” row (“On, set by your administrator” and what it covers); while they don’t, nothing. Regular users’ settings carry only that view (on with the categories and profile that apply, or off with none) and never the switch for everyone or the helpline text; admins get the settings as they are. Admin › Capabilities says plainly that safeguards are instructions to the model, which a determined person or a model that follows instructions poorly can get around, and that only the model provider’s own filters are a hard limit. Not built: a separate Admin › Safeguards page (the settings sit in Admin › Capabilities), per-person category and profile overrides, the composer’s shield indicator, and a classifier.
9.3 The block
Section titled “9.3 The block”safeguards.<tier>.md, rendered with only the enabled categories, the younger section when selected, and the crisis
resource when set (src/prompts/safeguards.ts). It says the administrator turned the safeguards on for this account,
that they apply to everything produced in the session and come before the person’s saved instructions and project
instructions; it limits declines to the listed categories, asks for one or two plain sentences that name the
workspace setting and offer an alternative, and forbids changing facts or favouring a political side because of it.
Each category lists what is still fine (sex education, arguing any political position, analysing extremism, criticism
of public figures, factual health questions without signs of risk, …).
The block is its own system block in every mode and in sub-agents (they inherit the person), never in compaction, title or web-fetch prompts. Its hash is the hash of the rendered text, so editing the template reaches live sessions; it is empty while safeguards are off, so category edits then rebuild nobody’s prompt. A change rebuilds the snapshot and adds the neutral note.
Prompt-only safeguards hold with models that follow their instructions; a determined person or an uncensored local model can get around them. A classifier (a local guard model or an external moderation API) is a possible later step.
10. Tests
Section titled “10. Tests”-
Assembled prompts (
src/prompts/builder.snapshot.test.ts): each case ofCASESinsrc/prompts/__fixtures__/prompt-cases.tsruns through the real ChatService with fixed inputs and writes its system blocks, first-message notes and tools JSON tosrc/prompts/__snapshots__/prompts/<case>.txt. Cases: every mode in both tiers, Chat without web, with a project, with personalization, prompted tools, Code in plan mode, without effort, sub-agents (general and defined), compact Code with three large connectors and over its total budget, Chat with the administrator’s instructions, and safeguards on for each mode and tier (default categories, all categories with the younger profile, per person, in a sub-agent). -
Invariants (
src/prompts/builder.test.ts): templates match their embedding; guards resolve, renumber and reject unknown conditions (also in overrides); every core carries the rules of §2; compact cores have at most twelve rules and placeholder examples; the compact budget cuts in its order, never the core, safeguards or<env>, and not in the full tier; the administrator’s instructions in every mode, ahead of the files and never cut; block order and the two breakpoints; the prefix and the tools JSON are byte-identical across models of a tier; no unrendered variable or guard; no absent tool is named, in the prompt, the first message’s notes or the notes that can arrive later (output limit, plan mode); sub-agents get no Agent tool and nothing personal; the effort sentence follows the effort control; size budgets; safeguards absent by default and present globally, per person, in sub-agents and despite a core override, and no block when nothing applies; escaping, its case and attribute rules with generics and other code left alone, and the document and command wrappers; model developers. -
Notes (
agent/context-notes.test.ts,agent/chat-service.test.ts): each note fires once per change; plan mode on every new branch, its notes naming only the session’s tools; a retried message told what is true now; model switch and safeguards changes rebuild the prompt; the off note is neutral; refresher cadence; Ultracode’s notes on the first turn, every tenth turn, when it is turned off, on an edited branch and after a compaction (unless the kept tail holds the full note), never for a clamped session or a sub-agent; the todo nudge; nested instruction files with escaped paths, in sub-agents too and forgotten when they finish (agent/permissions-flow.test.ts); the after-compaction part with skill names escaped as attributes; the output-limit continuation; escaping of the person’s text and of attached documents; connector tools stay as first seen when a server reorders or edits them, a compact prompt’s cut descriptions until the tier changes. The plan-mode refusal per tool set (permissions/permissions.test.ts). The sub-agent budget, and its return for a sub-agent that never started. A background sub-agent’s note at the next request or on a turn of its own, once, and a loop’s send with its note. A message between sessions at the receiver’s next step or on a turn it starts, both ways between a parent and its background sub-agent, the refusals, and the message chain cap (agent/session-messages.test.ts). -
Neutrality (
src/prompts/neutrality.test.ts): every template except the safeguards files, and every assembled case with safeguards off, is free of content-policy vocabulary; exceptions with reasons inneutrality.allow.txt. -
Originality (
src/prompts/originality.test.ts,scripts/check-prompt-originality.mjs): the templates, the assembled snapshots (their prose; schema keywords and parameter names are fixed) and this file must not contain a marker fromscripts/prompt-signature-phrases.txt. WithATELIER_PROMPT_CORPUSset to local copies of published prompts (colon-separated folders, never committed), any run of ten or more words shared with them fails and runs of eight or nine are listed for review; justified exceptions go inscripts/prompt-originality.allow.txt. Run it for every prompt change:Terminal window ATELIER_PROMPT_CORPUS=/path/to/corpus-a:/path/to/corpus-b node packages/core/scripts/check-prompt-originality.mjs -
UI: the provider-stop notice with Edit and Retry, and a reply’s Copy with escaped tags turned back (
features/chat/transcript.test.tsx); escaped tags shown as text in replies, files verbatim (features/chat/markdown.test.tsx); the read-only safeguards row in Settings › Account (account-page.test.tsx); the administrator’s instructions and the safeguards caveat in Admin › Capabilities (capabilities-page.test.tsx). -
End to end (
e2e/safeguards.web.spec.ts): the fake model reports whether the block reached its system prompt; absent by default, present after an admin sets a person to On, absent again on Default.e2e/effort.desktop.spec.ts: Ultracode’s note reaches the model on the first message only, and the off note once after a switch to Low.
Only real models can show whether the prompts change behaviour as intended, whether default prompts refuse no more
than an empty system prompt, and whether prompt-only safeguards hold on local models. The eval harness
(pnpm eval) is where those checks belong.
11. Not built yet
Section titled “11. Not built yet”Parts of the design that the prompts are worded not to claim:
- the lean tier for the newest frontier models;
- built-in
exploreandverifysub-agents, and scheduling that runs one writing sub-agent at a time (the prompts ask for it; nothing enforces it); - a read-only shell classifier for plan mode (shell commands stay blocked there);
- a read registry that makes Write and Edit refuse files not read in the session;
- a rule that deletes in a chat’s task always ask;
- git attribution in
<env>, theunattendednote, and the knowledge cutoff from the model catalog; - skipping nested instruction files in gitignored folders (dependency and build folders are skipped);
- a per-model compact budget;
- for safeguards: a separate Admin › Safeguards page, per-person categories and profile, the composer’s shield indicator, and a classifier;
- moving the remaining model-facing text in TypeScript (response styles, the project wrapper, the prompted-tools
specification, the permission refusals, the compaction wrapper) into
strings/.