Skip to main content

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.

This is the public glossary. For internal naming guidance and what not to call things, see the 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 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.

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

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

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

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

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

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