> ## 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

> Plain-English definitions of every Engine concept.

This is the public glossary. For internal naming guidance and what *not*
to call things, see the [internal glossary](../../internal/glossary).

## Agent

A configured behavior — system prompt, allowed tools, allowed model —
that runs inside the agent loop. The Engine ships several stock agents
(researcher, coder, analyst, writer); you can add custom ones by
dropping a definition in the catalog.

Different from a model: many agents share the same model, an agent is
the configuration around the call.

## Agent loop

The control loop that drives an 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.

See [The agent loop](../agents-and-tools/agent-loop) for the lifecycle.

## 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.

See [Asset Directory endpoints](../api-reference/endpoints/assets).

## 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 the brain;
TTL configurable.

See [Durability](../agents-and-tools/durability).

## Compaction

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

## Context

What the model sees on a single call: system prompt, soul, history,
working memory, retrieved memory, and tool definitions, in that order.
The Engine assembles context from these sources before each model call.

## 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).
A headless agentic execution platform: HTTP API, agent loop, memory,
sandbox, MCP connectors. Single-tenant per instance.

## Herald

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

## 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`.

See [HITL endpoints](../api-reference/endpoints/hitl).

## Knowledge fact

A unit of the knowledge store: a typed assertion (fact, rule, heuristic)
with confidence, source, and validity window. Knowledge facts are how
the Engine remembers "what's true" as opposed to "what happened."

## Learning Centre

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

## MCP

[Model Context Protocol](https://modelcontextprotocol.io). The open
standard the Engine uses to talk to external tool providers (Slack,
Gmail, Notion, Linear, etc.). Each connector is an MCP server.

## Memory

Umbrella term covering episodes, knowledge, social graph, working
memory, and the soul. The Engine's long-term and short-term storage
for what it knows about the user and what's happened.

## 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.

See [Permissions](../agents-and-tools/permissions).

## RPC

`POST /rpc`. A direct dispatcher for invoking skills and tools without
going through the agent loop. Useful for simple integrations that don't
need conversation state.

## Sandbox

The execution boundary tools run inside. Combines `bubblewrap`,
`seccomp`, and `landlock` for filesystem, syscall, and ACL isolation.

See [Code execution](../capabilities/code-execution).

## 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. Used when the agent needs to know who's who in the user's
world.

## 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.

See [Defining tools](../agents-and-tools/defining-tools).

## Trajectory

The complete record of an executed task — every turn, every tool call,
every result. Persisted as one row per task in the brain 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, including multiple model calls,
tool calls, and HITL pauses.

## Working memory

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