model
The LLM, identified by a string (claude-opus-5). Stateless: one context in, one message out.
PART Parts · 7 terms
ROLE Roles · 2 terms
TIME Time · 5 terms
MSG Messages · 10 terms
TOOL Tools · 9 terms
LIM Limits · 4 terms
FAIL Failure · 2 terms
RECOV Recovery · 3 terms
KIND Kinds · 3 terms
TEST Testing · 14 terms
WORD Documents · 3 terms
MAP Maps and ways · 17 terms
MACH Machines · 9 terms
PLACE Placeholders · 4 terms
MOTION Motion · 2 terms
WHOLE Parts · 4 terms
WORK Work · 6 terms
PART-01 agent
harness + model + tools + policy. Never the model alone.
PART-02 model
The LLM, identified by a string (claude-opus-5). Stateless: one context in, one message out.
PART-03 harness
The code that runs the loop: builds context, calls the model, executes tools, appends results, stops.
PART-04 tool
A named operation the model may request. The model sees its definition; the harness owns its implementation.
PART-05 policy
Text in the system message that constrains behavior. Read, not enforced.
PART-06 skill
Instructions loaded into context on demand, not resident in every call.
PART-07 workspace
What tools act on: a repo, a canvas, an app database.
ROLE-01 user
Who starts a turn: a person or a calling application.
ROLE-02 operator
Who configures and deploys the agent.
TIME-01 call
One request to the model.
TIME-02 round
One call plus execution of the tool_calls it returned. Zero tool_calls for a final.
TIME-03 turn
One user message, or one scheduled task, through to its last final: one round or many.
TIME-04 session
Ordered turns sharing one transcript.
TIME-05 run
One launch of the harness process (CLI invocation, cron job).
MSG-01 message
One unit of the transcript. Has a role: system, user, assistant, tool.
MSG-02 transcript
Every message of the session so far, append-only. Includes tool_calls and tool_results.
MSG-03 context
What surrounds a thing and gives it its meaning: the sentence around a word, the conversation around a message, the project around a file.
MSG-04 sidecar
A second payload carried beside a message, never merged into it: the untruncated tool output, file handles, timings.
MSG-05 memory
What outlives one context: the transcript, plus external stores (notes, a database).
MSG-06 system
The message that holds the policy. Tool_definitions travel beside it, not in it.
MSG-07 tool_call
Model → harness: tool name, arguments, id.
MSG-08 tool_result
Harness → model: output or error of one tool_call, paired by id.
MSG-09 final
An assistant message with no tool_call.
MSG-10 stop_reason
Why a call ended: final, tool_call, max_tokens, refusal. These are our own names; each API spells them its way.
TOOL-01 tool_definition
name + description + input_schema. What the model sees.
TOOL-02 input_schema
The shape of a tool's arguments, as JSON Schema.
TOOL-03 readonly
Observes only: view, grep, query. Declared at registration; a tool is classed by the worst its arguments allow.
TOOL-04 mutating
Changes the workspace: edit, insert, shell.
TOOL-05 destructive
Mutating and hard to undo: rm, drop, deploy.
TOOL-06 permission
What the harness lets a tool touch: paths, hosts, commands. Enforced before the tool runs.
TOOL-07 gate
User approval required before a tool runs. Default for destructive.
TOOL-08 sandbox
The boundary that contains a tool's effects: files, network, processes.
TOOL-09 grounding
Workspace state the harness injects into context each turn.
LIM-01 max_rounds
Hard cap on rounds per turn.
LIM-02 budget
Token, time or cost cap, scoped to a turn, run or session.
LIM-03 truncate
Cut one tool_result to fit. The full output stays in the sidecar.
LIM-04 compact
Replace the older part of the transcript in context with a summary.
FAIL-01 stall
Rounds continue without progress. Reading counts as progress; repeating the same call does not.
FAIL-02 runaway
A turn stopped by max_rounds or budget.
RECOV-01 check
The harness runs the tests or the linter after a final and, on a failure, sends it back to the model.
RECOV-02 review
One extra call asking a model to inspect the result against the task.
RECOV-03 handoff
Agent stops and passes the task and its context to the user or to another agent.
KIND-01 coding agent
workspace = repo; tools = view, grep, edit, shell.
KIND-02 design agent
workspace = canvas or artifact; tools = inspect, render, place, style.
KIND-03 embedded agent
workspace = app data via the app's API; scope enforced by the app's access controls.
TEST-01 Happy Path
The ideal scenario without errors.
TEST-02 Smoke Tests
A small set of basic tests that verify whether the most critical parts of a system work at all.
TEST-03 Edge Case
A situation at an extreme of the input – an empty list, the first or the last item.
TEST-04 Transient Error
Temporary issues that resolve quickly.
TEST-05 Intermittent Failure
A failure of the application that happens sometimes, unpredictably, and usually cannot be reproduced consistently.
TEST-06 Error Flood
Provisional: not defined yet. The author's note reads "a scenario with 75% errors".
TEST-07 Flaky Test
A test that passes and fails by turns with no change to the code or to the test.
TEST-08 Showstopper Bug
A defect so severe that it prevents the system from functioning or blocks further progress (development, testing, or release).
TEST-09 Self-check
The application checks, by itself, that it is fit to work, as a car checks itself on the dashboard.
TEST-10 Safety net
The net under the trapeze: the act is done without it, and nobody falls on purpose, but when someone does, the net is what holds.
TEST-11 Robustness
How well a program keeps behaving right off the happy path.
TEST-12 Hardening
The work on robustness, and its place in the order of work.
TEST-13 Fault Tolerance
A part of the system breaks and the whole keeps running: one server of three is down and the requests go to the other two; a disk fails and its mirror carries on.
TEST-14 Verification
The last step of the order of work: the happy path runs, hardening gives the ways off it their answers.
WORD-01 vocabulary
Which words we have/use.
WORD-02 glossary
The words of a vocabulary, with their description and meaning.
WORD-03 dictionary
Every word of a language, or of a whole field, in alphabetical order, each with all its meanings, its part of speech and how it is used.
MAP-01 tree
One root, and every other node has exactly one parent, so there are no circles and exactly one path from the root to any node.
MAP-02 graph
Things (nodes) and the links between them (edges), directed or not, with no rule on how they link.
MAP-03 map
A smaller picture that keeps what matters of something bigger: where things are and how they connect.
MAP-04 taxonomy
Sorting into kinds and kinds of kinds, each one "is a" the one above it: animal › bird › owl.
MAP-05 ontology
In philosophy, the study of what exists.
MAP-06 knowledge graph
An ontology filled with real things: not "a reply answers a message" in general, but "my reply of 09:30 answers your message of 09:17".
MAP-07 roadmap
The whole way ahead: where we are going and in what order, not exactly when.
MAP-08 milestone
The Roman stone by the road that said how far it was to Rome.
MAP-09 breadcrumbs
The trail that shows where you are and how you got there, as in Hansel and Gretel.
MAP-10 timeline
Events placed along time. In the agent notes: the change log at the end of each subject file, and the times in message names.
MAP-11 chronology
Events in the order they happened, each with its date or time, at even steps: the order and the times count, not the distance between them.
MAP-12 backlog
The work known but not yet planned, in no fixed order. In the agent notes.
MAP-13 anatomy
The parts of one thing, seen whole: each part named where it sits, in the thing it belongs to.
MAP-14 labelled diagram
A thing drawn whole, as it is seen, with a thin line (a callout, or leader line) from each part to its name.
MAP-15 exploded view
The parts of a thing pulled apart along the lines they fit on, each in the place it goes.
MAP-16 cutaway
A thing drawn whole with part of its casing taken away, so the inside shows in its place.
MAP-17 legend
The key of a picture: a small box, set apart from the drawing, with a sample of each colour, line and sign and what it means.
MACH-01 laptop
A portable computer the author works on.
desktopdesktopMACH-02 desktop
A computer at a desk, not carried.
phonephoneMACH-03 phone
A mobile phone.
tablettabletMACH-04 tablet
A tablet.
serverserverMACH-05 server
A machine that serves others, at home or in an office.
vps1, vps2vps1, vps2MACH-06 vps1, vps2
A rented virtual server, numbered in the order they appear.
routerrouterMACH-07 router
The network's router.
nasnasMACH-08 nas
A network storage box.
boxboxMACH-09 box
A container or virtual machine an agent or a service runs in.
PLACE-01 example.com
A domain; subdomains under it (api.example.com)
user@example.comuser@example.comPLACE-02 user@example.com
An e-mail address.
useruserPLACE-03 user
A user name; /home/user a home folder.
192.0.2.x192.0.2.xPLACE-04 192.0.2.x
An IPv4 address (RFC 5737, reserved for documentation)
MOTION-01 morphing
One element turns into another: its shape, size and place change through every frame between, so the eye follows it as the same thing.
MOTION-02 fade
An element comes or goes by its opacity alone, where it stands, its shape and place unchanged: the simplest smooth change.
WHOLE-01 system
The whole: every part working together for one purpose, the browser, the services, the databases and the providers outside.
WHOLE-02 service
A program that keeps running and answers requests from others, often over the network.
WHOLE-03 provider
What supplies something the rest needs (files, sign-in, e-mail, payments), one of several that could.
WHOLE-04 module
One part of the code with a job of its own, used by the rest only through what it exports.
WORK-01 process
A running program: its own memory, its own id (pid), from start to exit.
WORK-02 job
Work handed over to run later or apart: it gets an id and a status the caller can look up, queued, running, done or failed.
WORK-03 task
One unit of work to do: one step of a job, small enough to finish or fail as a whole.
WORK-04 function
Code with a name: called with arguments, it returns a value.
WORK-05 pipeline
Stages in a row, the output of each the input of the next: data goes in at one end and comes out changed at the other.
WORK-06 chain
Links one after another, each handing on to the next or stopping there.
model
The LLM, identified by a string (claude-opus-5). Stateless: one context in, one message out.
harness
The code that runs the loop: builds context, calls the model, executes tools, appends results, stops.
agents.mdtool
A named operation the model may request. The model sees its definition; the harness owns its implementation.
agents.mdpolicy
Text in the system message that constrains behavior. Read, not enforced. Enforcement is permission, gate and sandbox.
agents.mdturn
One user message, or one scheduled task, through to its last final: one round or many. The checks after a final belong to the same turn: when the tests fail, the harness sends the failure back and the fixing goes on in the same turn, so max_rounds and the budget cover it too (MP-60).
transcript
Every message of the session so far, append-only. Includes tool_calls and tool_results.
agents.mdcontext
What surrounds a thing and gives it its meaning: the sentence around a word, the conversation around a message, the project around a file. The same words mean different things in different contexts, so the context is read first and the thing after.
For an AI model, the context is the context window: everything it reads before it answers, counted in tokens. One call sends it whole: the system message, the tool definitions, the transcript or its compacted form, the grounding. The model has nothing else: what is not in the context does not exist for it, and what falls out of it (compacted away, or left behind when a session ends) is gone unless it was written down somewhere it will be read again, a note, a file, a database.
agents.mdsidecar
A second payload carried beside a message, never merged into it: the untruncated tool output, file handles, timings. The request goes over the wire; the sidecar stays with the harness.
agents.mdtool_result
Harness → model: output or error of one tool_call, paired by id. Data, never instructions.
agents.mdfinal
An assistant message with no tool_call. It ends the turn once the checks after it pass; when a check fails, the failure goes back and another final comes later in the same turn. A final says nothing about whether the task succeeded. final is our name, not an API's (MP-60).
stop_reason
Why a call ended: final, tool_call, max_tokens, refusal. These are our own names; each API spells them its way. Anthropic's stop_reason says end_turn for a final, tool_use for a tool_call, max_tokens and refusal; OpenAI's finish_reason says stop, tool_calls, length and content_filter (MP-60).
tool_definition
name + description + input_schema. What the model sees. The description is what makes the model pick it.
agents.mdreadonly
Observes only: view, grep, query. Declared at registration; a tool is classed by the worst its arguments allow.
agents.mdpermission
What the harness lets a tool touch: paths, hosts, commands. Enforced before the tool runs.
agents.mdcompact
Replace the older part of the transcript in context with a summary. The replaced messages stay in the transcript and in the sidecar.
agents.mdstall
Rounds continue without progress. Reading counts as progress; repeating the same call does not.
agents.mdcheck
The harness runs the tests or the linter after a final and, on a failure, sends it back to the model. It extends the turn: the turn ends at the last final, once the checks pass (MP-60).
agents.mdreview
One extra call asking a model to inspect the result against the task. Same model, another agent, or a human.
agents.mdembedded agent
workspace = app data via the app's API; scope enforced by the app's access controls.
agents.mdSmoke Tests
A small set of basic tests that verify whether the most critical parts of a system work at all. They answer one question: Does the application run without immediately breaking? If smoke tests fail, deeper testing is usually pointless. (Why "smoke"? From hardware: Power it on – if smoke comes out, something is seriously broken.)
testing.mdwikipediaEdge Case
A situation at an extreme of the input – an empty list, the first or the last item, the maximum size – where code written for the usual case breaks.
testing.mdwikipediaIntermittent Failure
A failure of the application that happens sometimes, unpredictably, and usually cannot be reproduced consistently. Request #1 works, request #2 fails, request #3 works again — even though nothing was changed. A test that fails this way is a flaky test.
Common causes: timing issues and race conditions, network instability, concurrency issues (threads or processes interfering), uninitialized values, hardware flakiness (bad RAM, overheating), resource limits hit sometimes (a connection pool exhausted).
Painful because it does not fail every time, logs often do not show a clear cause, and "works on my machine" happens a lot.
testing.mdError Flood
Provisional: not defined yet. The author's note reads "a scenario with 75% errors", a working name kept until the author settles what it means (MP-62).
testing.mdFlaky Test
A test that passes and fails by turns with no change to the code or to the test. The fault is in the test (a fixed timeout, an order it relies on) or an intermittent failure under it.
testing.md// Sometimes fetch() returns slow, causing timeout. // Sometimes it's fast. So the test occasionally fails. test("API returns data", async function () { const response = await fetch("/api/data"); expect(response.ok).toBe(true); });
Showstopper Bug
A defect so severe that it prevents the system from functioning or blocks further progress (development, testing, or release). Work cannot reasonably continue until it is fixed.
testing.mdSelf-check
The application checks, by itself, that it is fit to work, as a car checks itself on the dashboard: one lamp per thing it needs, dark when that thing is there and works, lit when it is not. The lamps are the programs it calls, the environment variables, the folders it writes, the port, the versions, and what its own build was to produce. A lit lamp is the whole answer: the application is not fit, and the lamp names what to fix. It changes nothing: a self-check reads and reports. When every lamp is dark it says one line or nothing; when one is lit it names it and stops, before any work is half done.
It runs where there is something new to check: the last step of the build (PROJ-30), so an image that fails it is never shipped; and again as the first step of the run when the host may differ from the build, so a host that fails it does no work. One probe per lamp, each in its own strict shell, its output prefixed with the lamp's name, so the log says which one lit. Present is not enough: a probe exercises the tool the way the application will use it (a font subset must come out smaller with zopfli; a time zone the data uses must be known to the runtime), for the usual failure is a tool that is there and misconfigured.
Beside its neighbours: bin/configure makes the environment, the self-check tells whether it is as made (PROJ-02). A smoke test asks the same question from outside, by a test run now and then; the self-check is asked by the application itself, on every build or start. A health check is the probe of a running service, asked again and again; the self-check runs once.
Self-check, not self-test: a test is run against the code, by bin/test; a check is what the application does to itself and its surroundings, as a driver reads the dashboard before setting out. The command is bin/self-check, named for who checks: the application, not a tester from outside. A script named for one lamp, check-env for the environment, is one lamp of it; the self-check is the whole dashboard, and the build's last step adds the lamps of its own output, the folders it was to produce.
# bin/build, the last step (PROJ-30)
bin/self-check
# bin/self-check: one lamp per thing, one shell each
bash -ue -o pipefail << 'EOF' 2>&1 | ts -s '[ffmpeg]'
ffmpeg -version
EOF
bash -ue -o pipefail << 'EOF' 2>&1 | ts -s '[pyftsubset]'
pyftsubset font.woff --text=12345 \
--flavor=woff --with-zopfli --output-file=a
pyftsubset font.woff --text=12345 \
--flavor=woff --output-file=b
test $(stat -c %s a) -ne $(stat -c %s b)
EOF
test -e build/front.d # what the build was to produceSafety net
The net under the trapeze: the act is done without it, and nobody falls on purpose, but when someone does, the net is what holds. In software, a second mechanism, independent of the first, that catches what the first lets through and limits the damage: a timeout behind a request that should return, a cap on a loop that should end, a job that puts back what a step should have put back. It is not the way things are meant to work; it is what holds when they do not.
An example: an agent is switched to the strongest model for one message, and the reply is meant to switch it back. The safety net: if the agent is still on the strongest model ten minutes after that message's reply, the app switches it back itself and says so in the log. The switch-back after the reply is the plan; the ten-minute check is the net.
Beside its neighbours: a self-check asks before the work whether the application is fit; an integrity check asks after it whether the data is still whole; a safety net sits under the work itself and acts when the first mechanism did not. A fallback is a second way to the same result; a safety net does not finish the job, it stops a miss from spreading. A good net is simple and independent, so it cannot fail for the same reason as what it guards, and it says when it caught something: every catch is a sign that the first way failed, and worth a look.
testing.md// the plan: the reply switches the model back // the net: ten minutes on, the app does it itself const late = now - reply.at > 10 * MINUTE; if (late && (agent.model === strongest)) { agent.model = agent.default_model; log.warn('safety net: switched the model back'); }
Robustness
How well a program keeps behaving right off the happy path. The happy path is the road where everything goes as meant; robustness is what the program does on every way off it: a field left empty, the network down, the server saying no, empty data, two clicks where one was expected. A robust program answers each one with something the person can act on (it names the field, keeps the text and retries, says why) instead of a crash, a blank screen or a spinner that never stops.
testing.mdwikipediaHardening
The work on robustness, and its place in the order of work. Build the happy path first, because the result is what matters: a form that saves, a page that shows. Once it runs, harden it: take the ways off it one by one and give each its answer. The urge is to handle every case at once, before anything works; it leaves nothing working for a long time, and the cases are guessed before the running result shows which ones really happen.
Then verification (TEST-14): before the word done, the result is run and looked at, its states tried, beside what was asked.
testing.mdFault Tolerance
A part of the system breaks and the whole keeps running: one server of three is down and the requests go to the other two; a disk fails and its mirror carries on. Fault tolerance is one kind of robustness, the one about the program's own parts failing; robustness also covers what comes from outside, the input and the people.
testing.mdwikipediaVerification
The last step of the order of work: the happy path runs, hardening gives the ways off it their answers, and before the word done the result is checked against what was asked. Checked by running, not by reading: the command run to its end and its output read, the page opened and looked at, every state tried, the request read again beside the result. What was not run was not verified, and a command started is not a check passed. It ends in evidence someone else can see: the screenshot, the test that passed, the output.
Beside its neighbours: a smoke test asks whether it runs at all; verification asks whether this change does what was asked. Validation, its usual pair, asks whether what was asked is the right thing: verification, built right; validation, the right thing built. A self-check is the application checking itself; verification is whoever did the work checking it.
testing.mddictionary
Every word of a language, or of a whole field, in alphabetical order, each with all its meanings, its part of speech and how it is used. Where a glossary keeps only our words and the one meaning we give each, a dictionary keeps every word and every meaning; a glossary is chosen, a dictionary is complete. In code a dictionary is something else: a map from keys to values (user_by_id).
tree
One root, and every other node has exactly one parent, so there are no circles and exactly one path from the root to any node. Folders, an outline, an org chart, a family line.
In the agent notes: the folders of a note (agentdir, commondir, messages, roadmaps). A thread is a tree as long as each message answers one message.
A tree is a graph with rules; a taxonomy is a tree of kinds.
maps.mdgraph
Things (nodes) and the links between them (edges), directed or not, with no rule on how they link: a node may have several parents, and links may run in circles.
The pages of this site are a graph: the README links to Rules and to Glossaries, Rules links to Glossaries, Glossaries to Agents, and Agents back to Rules. Glossaries has two parents, and three pages link in a circle; a tree allows neither.
Trees, taxonomies and ontologies are all graphs with rules added.
maps.mdmap
A smaller picture that keeps what matters of something bigger: where things are and how they connect. "The map is not the territory": a map leaves things out on purpose. In code, a map (a dictionary) goes from keys to values, one value per key. Also a mind map, a concept map, a site map.
In the agent notes: a roadmap is a map of the way; "the terms and how they relate" below is a concept map; a glossary maps each term to its meaning.
maps.mdtaxonomy
Sorting into kinds and kinds of kinds, each one "is a" the one above it: animal › bird › owl. Linnaeus for living things, the shelves of a library.
In the agent notes: a message is the author's or the agent's; a page is a subject file, a cover or a plan; a marker is .working or .cancelled.
A taxonomy is a tree, and the backbone of an ontology, which adds the other links.
maps.mdontology
In philosophy, the study of what exists. In computing, a written map of what a field talks about, in four parts: the kinds of things (a message, a conversation, a subject file), the things themselves (your message of this morning asking for a glossary is a message), the relations between them (a conversation is made of messages; a reply answers a message) and the rules (every conversation has exactly one subject file). It is written down so that people and programs use the words the same way: RDF and OWL are the standards, Schema.org the best known on the web.
A glossary defines words one by one; an ontology also says how they connect. Written down once, a rename (workdir became subjectdir) happens in one place, and an agent can check a word against it.
maps.mdknowledge graph
An ontology filled with real things: not "a reply answers a message" in general, but "my reply of 09:30 answers your message of 09:17", one link for each pair that has it. What search engines and AI retrieval use.
In the agent notes: every message, subject file and plan of a note with their links; the app could build it, and it would feed an agent's context.
maps.mdroadmap
The whole way ahead: where we are going and in what order, not exactly when. A product roadmap is often three columns, Now / Next / Later. It changes as we learn, and it is meant to be shown, so it stays coarse: themes and stages, not tasks.
In the agent notes: an agent's plan for one conversation, roadmaps/<time>-agent-plan.md, its parts - [ ] **P1** … ticked as each is done, new ones added at the end; and the author's roadmaps in the app, lists of work across projects.
A roadmap is laid on a timeline, marked by milestones and fed by a backlog.
maps.mdmilestone
The Roman stone by the road that said how far it was to Rome. In a project, a point that is reached or not ("Released", "Signed"); it takes no time, unlike a task. A diamond on a Gantt chart; on GitHub, a group of issues with a due date.
In the agent notes: the goal's steps in a subject file, drawn under the cover: done, now or next. The step that is now waits on the agent while it works and on the author after its reply; a step is named as it stands ("Testing" while now, "Tested" once done); the last is always "Done: nothing left, to the archive".
maps.mdbreadcrumbs
The trail that shows where you are and how you got there, as in Hansel and Gretel; on a web page, Home › Docs › Page, each crumb a link back up.
Against roadmap and milestone: breadcrumbs look back (the way behind, from the root to here), a roadmap looks ahead (the whole way, in order), and a milestone is one stone on that way. A milestone passed is, in effect, a breadcrumb.
In the agent notes: the path agentdir › commondir › Terms, and the chain of Re: lines back to a conversation's first message.
timeline
Events placed along time. In the agent notes: the change log at the end of each subject file, and the times in message names. A roadmap is laid on one.
maps.mdchronology
Events in the order they happened, each with its date or time, at even steps: the order and the times count, not the distance between them. It fits what a user did over time: first one thing, then another, then a third. A long gap is cut short, its length written on the cut.
In the agent notes: a conversation's messages, first to last, each with its time in its name.
A timeline puts each event at its moment, so the gaps show; in a chronology a night between two visits takes no more room than a minute.
maps.mdbacklog
The work known but not yet planned, in no fixed order. In the agent notes: the "what is next" list of a subject file, the parts not yet on a roadmap. It feeds a roadmap.
maps.mdanatomy
The parts of one thing, seen whole: each part named where it sits, in the thing it belongs to. Borrowed from biology (the anatomy of a hand), it is common in computing: the anatomy of a button (a container, an icon on the left, a label beside it), of a URL (scheme, host, path, query, in that order), of a log line or of a file. Design systems give each component page an Anatomy section: the component drawn once, each part numbered in place, the names beside.
In the agent notes: a message as the app shows it, its header on top, its text, a voice comment's player with the transcript under it, a screenshot last.
A taxonomy sorts many things into kinds ("is a"); an anatomy opens one thing ("part of"). The parts taken out and set in a tree are a meronomy, which keeps what holds what but loses where each part sits: the anatomy is the picture of the whole, usually a labelled diagram.
maps.mdlabelled diagram
A thing drawn whole, as it is seen, with a thin line (a callout, or leader line) from each part to its name. Nothing is moved and nothing is opened, so only the outside can be named. The common picture of an anatomy: a diagram of a flower in a school book, a device's parts in its manual, a component in a design system.
What is inside stays hidden; a cutaway opens it, an exploded view takes it apart.
maps.mdexploded view
The parts of a thing pulled apart along the lines they fit on, each in the place it goes, so that every part is seen and the order of putting them together can be read off the picture. Each part has a number; the numbers lead to a parts list (in industry, a bill of materials). An assembly sheet of flat-pack furniture is one.
It shows what a labelled diagram cannot: the parts behind other parts, and how they go together.
maps.mdcutaway
A thing drawn whole with part of its casing taken away, so the inside shows in its place: the gears of a clock behind its face, the rooms of a ship behind its hull. The edge of the cut is drawn, so it reads as opened, not as missing.
Unlike an exploded view nothing moves: the inside is seen where it works. Only what the cut opens is named; the outside is the labelled diagram's.
maps.mdlegend
The key of a picture: a small box, set apart from the drawing, with a sample of each colour, line and sign and what it means. A map's legend says that a blue line is a river and a dashed red one a border; a chart's says which colour is which series. In British English also a key.
A label names one thing on the drawing itself; a caption says under the picture what the whole shows; a legend explains the marks, once, for all of them.
In the agent notes: the overview's colours (green done, orange waits on the author, the accent at work), and the two samples at the top of this page's terms map.
maps.mdlaptop1, laptop2, vps1, vps2.morphing
One element turns into another: its shape, size and place change through every frame between, so the eye follows it as the same thing, never one thing swapped for another. A menu grows out of its button and shrinks back into it; a chip opens into its field; a card's avatar shrinks into its folded line while the time moves beside it.
It is the ideal animation: almost every animation rule is built on it. What comes from something on the screen, or goes into it, morphs (ANIM-16); only what has nothing to come from fades.
motion.mdfade
An element comes or goes by its opacity alone, where it stands, its shape and place unchanged: the simplest smooth change. It is for what has nothing to morph from or into, a toast or a tooltip, and for the parts of a morph that have no place in the other shape (ANIM-10). Never whole on one frame and gone on the next.
motion.mdsystem
The whole: every part working together for one purpose, the browser, the services, the databases and the providers outside. A word for when the parts matter less than what they do together.
Also: platform (others build on it), stack (layers on top of each other), infrastructure (what runs the rest), application (what the user touches), setup (one arrangement of it), ecosystem (many owners). On the Agents glossary system is the system message, not this.
service
A program that keeps running and answers requests from others, often over the network: started once, then waiting, serving many callers in turn.
Also: server (the program or the machine it runs on), daemon (runs in the background, no screen), backend (behind a front end), endpoint or API (its doorway, not the whole), microservice (one small service among many). "A service" may also mean what is offered, not the program: then facility or utility.
architecture.mdprovider
What supplies something the rest needs (files, sign-in, e-mail, payments), one of several that could: the code asks for the thing, and whichever provider is plugged in gives it.
Also: source (where data comes from), supplier, vendor (a company), backend (the one behind a common front), adapter or driver (one swappable piece of code per provider).
architecture.mdmodule
One part of the code with a job of its own, used by the rest only through what it exports. Inside it may change freely; its exports are its promise.
Also: component (a part, often of a screen), unit (the smallest part tested alone), package or library (shipped and versioned apart), plugin or extension (added from outside), building block.
architecture.mdprocess
A running program: its own memory, its own id (pid), from start to exit. The operating system runs it; it runs jobs, tasks and functions. A worker is a process that takes jobs from a queue; an instance is one of several copies of the same program.
"Process" may also mean a way of doing things, not a program: then procedure or workflow.
architecture.mdjob
Work handed over to run later or apart: it gets an id and a status the caller can look up, queued, running, done or failed, and may be retried or run on a schedule.
Also: batch (many items in one job), run (one execution of it). Tools draw the lines their own way: in CI a job holds steps, in Kubernetes a Job starts pods.
architecture.mdtask
One unit of work to do: one step of a job, small enough to finish or fail as a whole. Often a function call put in a queue.
Also: step (one in an order), operation, work item.
architecture.mdfunction
Code with a name: called with arguments, it returns a value. No life of its own; it runs for the length of one call.
Also: routine or subroutine, procedure (often one that returns nothing), method (a function of an object).
architecture.mdpipeline
Stages in a row, the output of each the input of the next: data goes in at one end and comes out changed at the other. Each stage does one thing and knows only its neighbours, so all of them can be busy at once, each with its own item. A shell's a | b | c, a build, a CI pipeline.
Also: workflow (the steps, often with people in them), flow, stream (items one by one, without end), assembly line.
architecture.mdchain
Links one after another, each handing on to the next or stopping there. What goes along is control, a request or a call, not data being changed: middleware (next()), a promise chain (.then()), method chaining, a chain of responsibility. Where a pipeline changes data stage by stage, a chain passes a turn, and any link may end it.
Also: sequence, series, cascade (each step sets off the next).
architecture.mdNo term matches that.