> ## Documentation Index
> Fetch the complete documentation index at: https://internal.september.wtf/llms.txt
> Use this file to discover all available pages before exploring further.

# Glossary

> One canonical name for each concept in the Engine.

Every project ends up using three or four words for the same thing within
six months. This page is the dictionary that prevents that. When you write
docs or code, use these words and only these words.

## Agent

A configured behavior — system prompt, allowed tools, allowed skills —
that runs inside the agent loop. Examples: "researcher," "coder,"
"analyst." Different from a model: many agents share the same model, an
agent is the configuration around the call.

## Agent loop

The control loop in `engine_core/coordinator.py` that drives the agent
from a user message to a final answer, calling the model and tools as
needed. One `/execute` call runs one turn through the loop, which may
iterate many times internally.

## Asset Directory

The Engine's MCP connector subsystem. Holds the registry of available MCP
servers, the user's active connections, encrypted credentials, and the
OAuth machinery for establishing new connections.

Code: `src/asset_directory/`.

## BAP

Backend Application Platform. The upstream router that sits in front of
many Engine instances. Owns user accounts, billing, and the user-to-engine
mapping. Lives in [bap-backend](https://github.com/septemberai/bap-backend).

## Brain

The per-user SQLite database. Holds memory (episodes, knowledge, social
graph), conversation history, channel state, asset directory entries,
trajectories, and observability events. Default path inside the Engine
container is `/data/brain.sqlite`.

## Channel state

The execution checkpoint. Lets a disconnected client reconnect to a
streaming `/execute` call without losing events. Stored in
`channel_state_snapshots`. TTL configurable via
`CHANNEL_STATE_TTL_ACTIVE` / `CHANNEL_STATE_TTL_HITL`.

## Compaction

The process of collapsing earlier turns and tool results into summaries
when context gets too long. Runs in-line during execution if
`REACTIVE_COMPACT_ENABLED=true`.

Code: `src/engine_core/compaction_orchestrator.py`.

## Context

What the model sees on a single call: system prompt, soul, history,
working memory, retrieved memory, and tool definitions, in that order.

## Episode

A unit of episodic memory. One past event, conversation, or outcome,
stored with a vector embedding and full-text index for retrieval.

## Engine

The runtime in [`septemberai/engine`](https://github.com/septemberai/engine).
Always "the Engine," capitalized, with the article. Never "September
Engine" or "Intelligence Engine."

## Herald

The unified LLM provider abstraction. Wraps Anthropic, OpenAI, and Gemini
behind a single interface that handles streaming, prompt caching, quota,
and token budgeting.

Code: `src/herald/`.

## HITL

Human-in-the-loop. The mechanism the agent uses to pause and ask the user
a question or request permission. Surfaced through `hitl_request` SSE
events; resumed via `POST /hitl/respond`.

## Knowledge fact

A unit of the knowledge store: a typed assertion (fact, rule, heuristic)
with confidence, source, and validity window.

## Learning Centre

The background batch job that turns trajectories into episodes and
knowledge facts. Runs every `LC_BATCH_INTERVAL_HOURS` (default 6).

Code: `src/learning_centre/`.

## MCP

Model Context Protocol. The standard the Engine uses to talk to external
tool providers. Each connector is an MCP server.

## Memory

Umbrella term covering episodes, knowledge, social graph, working memory,
and the soul.

## Permission prompt

A specific kind of HITL request raised by the sandbox before running a
risky operation. The user answers `yes` or `no`; the result is cached
inside the task to avoid repeated prompts.

## RPC

`POST /rpc`. A direct dispatcher for skills and tools, outside the agent
loop. Different from "RPC" in the systems sense.

## Sandbox

The execution boundary tools run inside. Combines `bwrap`, `seccomp`, and
`landlock`. Code: `src/sandbox/`.

## Skill

A reusable capability — typically a prompt template plus optional helper
scripts. Stored in the brain. Different from a tool: tools are atomic
operations (read file, run bash); skills are composed prompts that may
internally use tools.

## Soul

The user's core identity and learned patterns. A single object with a
short summary version (`/memory/soul`) and a full version with metadata
(`/memory/soul/full`).

## Social graph

The people-and-relationships memory store. Nodes are people; edges are
relationships.

## Task

A conversation thread, identified by `task_id`. Reusing a `task_id`
continues the same thread; using a new one starts fresh.

## Tool

An atomic operation the agent can call. Three kinds:

* **Platform tools** — built-in (read, write, bash, etc.).
* **MCP tools** — surfaced from connected servers.
* **Skills as tools** — skills can also be invoked as tools.

## Trajectory

The complete record of an executed task — every turn, every tool call,
every result. Persisted as one row per task in `trajectories` for the
Learning Centre to consume.

## Turn

One user message and the agent's full response to it. May involve many
internal iterations of the agent loop.

## Working memory

Transient context the agent accumulates within a single turn or task.
Persisted in `working_memory_log` with a TTL. Different from long-term
memory (episodes, knowledge).

## Don't use

Words to avoid because they're ambiguous, internal, or already mean
something else:

* "Session" — ambiguous between channel state and conversation. Use
  "task" for conversation threads, "channel state" for the execution
  checkpoint.
* "AI assistant" — generic; use "agent" for our configured agents and
  "model" for the underlying LLM.
* "Memory" with no qualifier when you mean a specific store. Say
  "episode," "knowledge fact," "soul," etc.
* "September Engine" / "Intelligence Engine" — just "Engine."