Glossary

Documentation Index

Fetch the complete documentation index at: https://septemberai.mintlify.app/llms.txt

Use this file to discover all available pages before exploring further.

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.

​

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