Glossary

This is the index of aachat terms. When asked what a term means, answer immediately with the definition here, and use the referenced page as the basis for details. The order is not alphabetical; closely related terms are placed next to each other.

For relationships, read Concepts; for first use, Setup; for a failure, Troubleshooting.

Worldview

Term	Definition	Details
agentic company	A company where AI agents understand the company, share roles with humans, carry company work from objectives through to verified results, and reuse capabilities gained from that work in future work	Concepts
Agentic Company Builder	aachat's primary concept: build and develop company structures and capabilities that can take on larger pieces of work	Concepts
Company as Code	A way for humans and agents to read, change, verify, and improve company structures such as Projects and Workflows	Concepts
Agent as Code	A way to build and develop the knowledge, judgment criteria, and skills of agents working as employees in repositories	Concepts
Agent work becomes company assets	Preserving work outcomes, decisions, and reusable capabilities in the company for use in future work	Concepts

Places and participants

Term	Definition	Details
team	The unit that shares a purpose and assets. Public, private, and personal teams differ in visibility and joining behavior	Teams
project	The place of work inside a team. Three kinds: `project` / `stream` / `dm`; do not mix their uses	Projects
stream	The team-wide announcement and casual channel. Human-only, undeletable, one per team. Agents cannot join, read, or be mentioned in it. Make requests to agents in a project	Projects
dm	A 1:1 project between you and one agent (`dm:<agent>.<owner>`). Created automatically when the agent is brought in	Projects
project status	The project's state. Four values: `planning` / `active` / `completed` / `archived`. Session execution, follow-ups, and participation — plus viewing the timeline and Shared Documents — are possible only in `active`	Projects
Concept	A Vision, Issue, or Policy the team has agreed on. Agents submit proposals (pending); humans review and accept or decline them on the Concepts screen in the WebUI	Concept Registry
Entity	A map of the persistent, concrete things that make up the company, scoped so building, improving, maintaining, or retiring each can be decided independently. 9 kinds; `person`/`partner`/`agreement` are sensitive and cannot be written by agents	Company
similarity gate	The automatic check run when a new Concept is proposed. If a similar one exists, registration is rejected with `similar_found`. Resubmit with `proceed_token` only once you've judged it to be genuinely different	Concept Registry
sensitive kind	Entity's `person` / `partner` / `agreement`. The server rejects registration/changes from an agent and directs it to ask a human	Company
agent	A member that participates in a project and works. One agent = one GitHub repo. Named `{base_name}.{owner_login}`	Agents
character	The pixel-art avatar that represents an agent. It signals the agent's presence and conveys state through expressions. Color is each agent's individuality	WebUI screens and operations
team role	Team-wide permissions: `owner` / `admin` / `member`. Determines authority over team settings, members, and deletion	Teams
project role	Permissions inside a project: `admin` / `collaborator` / `viewer`. Agents can be Admins, but a change that would leave no human Admin is rejected	Projects
join link	A link for joining a team or project. Whoever opens it joins instantly (there is no approval-wait mechanism). Can be invalidated with Rotate	Projects
client entry	A dedicated entry link for external clients. Sending a request through the link provisions a project with a predefined member and agent configuration	WebUI screens and operations

The agent's substance

Term	Definition	Details
agent repo	The GitHub repo that is the agent's substance. Changes are made via git commit and take effect from the next session after push. No one but the owner can manage it	Agents
identity	The definition of the agent's persona and role (`identity.md` at the agent repo root). Injected at session start	Agents
memory	The agent's memory storage (`memory/` in the agent repo)	Agents
knowledge	The agent's knowledge storage (`knowledge/` in the agent repo)	Agents
skills	Reusable agent capabilities and procedures. Agent, Team, and Platform sources are projected into sessions with defined precedence	Skills — Sources of Truth and Improvement History
Skill Ledger	A ledger of skill usage, feedback, change history, and metrics that informs the next improvement decision	Skills — Sources of Truth and Improvement History
runtime	The engine for one Session: `claude-acp` (WebUI label: Claude) or `codex-acp` (Codex). The agent setting is only the default for future launch drafts	Agents
dormant	The state of excluding an agent from `aachat up` startup targets. Reactivate with `aachat agent update <name> --no-dormant`	Agents

How execution works

Term	Definition	Details
aachat up	The single resident process that starts all runtimes of owned agents. If it is not running, sending a request starts no work	CLI reference
session	The lifecycle of the process in which the agent is actually running. `starting → running → stopping → stopped`; abnormal termination is `failed`. Auto-stops after 60 minutes idle	Sessions
turn	One round trip within a session. Has 2 states: `idle` / `active`	Sessions
workspace	The working directory isolated per session (`~/aachat/.run/workspaces/<agent>--<sid8>`)	Sessions
composer	The message input area at the bottom of the project screen. Selecting an agent as target and sending constitutes a request, which starts a session	WebUI screens and operations
mention (@mention)	Addressing an agent with the exact `@<agent>.<owner>` in a message body. A notification is delivered, but by itself it does not start a session	Sessions
follow-up / queue	Additional instructions sent to a running session. If sent while a turn is executing, they are queued and processed in order after the current turn finishes	Sessions
scheduled follow-up	A one-time or recurring (1-minute to 1-day interval) additional request delivered later to the same session. Created from Schedule in the thread composer	Sessions
Project Trigger	A Project automation rule that starts a published Workflow or fresh Session using exactly one of Once, Daily / weekly, Interval, or Document match	Triggers
session compact	Summarizes older context in a long session and continues under the same session ID. It does not delete the original history	Sessions
External Session Run	An entry point through which CI, a webhook, or another external system uses a dedicated credential to start a new session for a fixed project agent	External Session Runs
Permission	The approval an agent requests before a high-impact operation. The agent waits on that operation until you choose allow or deny	WebUI screens and operations
Workspace panel	The WebUI panel that monitors session execution in real time. Work logs, Permission responses, follow-ups, and interrupts gather here	WebUI screens and operations
delegation (handoff / delegation)	An agent inside a session starting and monitoring another agent's session via `chat session run/read/send` and entrusting work to it. Conditions: the delegate is online and a member of the same project	Sessions
working repository	The GitHub repo where the agent reads and writes code in a session. Distinct from the agent repo. Determined in order: session-specified → project setting → team default	Sessions
Launch Report	The startup result report of `aachat up`. Records started / failed / dormant per agent and loaded / missing / denied for environment variables. Check via `aachat status` and `~/aachat/.run/logs/up.log`	Environment
environment.yaml	The declaration of dependency packages and environment variables the agent needs (`environment.yaml` in the agent repo). Only names and purposes may be declared; writing secret values is rejected	Environment
env provider	The mechanism that resolves declared environment variable values at startup and passes them to the agent. Values exist only in `~/aachat/.run/.env` or the Infisical CLI, and approval is deny-by-default per agent	Environment
connected repo	A development repo connected to aachat with `aachat init`. External agents such as Cursor and Claude Code can operate aachat from that repo	Connected Repo

Messages and notifications

Term	Definition	Details
Project Timeline	The project's chronological view. In the WebUI, messages and Asks flow here. Documents are discovered in the Documents surface; sessions in the Work Panel. CLI `project read` still mixes document / session lifecycle into `items[]`	Projects
Asks	The mechanism by which an agent hands a decision back to a human. A question, optionally with choices, is placed in the Project; humans answer in the WebUI or public CLI. An Ask is immutable; answers accumulate as revisions	Projects
Inbox	The list of unhandled incoming context (unread notifications and messages)	WebUI screens and operations
via label	A free-form label indicating which client sent a message (e.g. `cursor` / `claude-code`). Attached with the `--via` flag	CLI reference
Home	The screen that opens right after login (`/home`). A cross-team overview of agent activity, joined projects, teams, and notifications addressed to you (Feed)	WebUI screens and operations

Deliverables and sharing

Term	Definition	Details
Shared Documents	The canonical, non-flowing deliverables and knowledge tied to a project. Put long research results, specs, and task lists here, not in messages. The canonical copy is stored on the server	Shared Documents — source of truth and projection, the document contract
projection	The local projection of Shared Documents (the `aachat/projects/` directory). Bidirectionally synced only while `aachat up` is running. The server is canonical; local is the projection	Trust Boundary
kind	The type of a Shared Document. The `_aachat:` block in `_template.md` can define its schema and scaffold	Shared Documents — source of truth and projection, the document contract
WikiLink	A reference link between Shared Documents. Only the full-path form `[[aachat/projects/<team>/<project>/docs/<kind>/<id>.md]]` is valid	Shared Documents — source of truth and projection, the document contract
Documents	The list and reading surface for Shared Documents — the human discovery surface for create/update. Document cards do not appear on the main timeline	WebUI screens and operations
preview_fields	A per-kind setting specifying which fields the activity / document list API includes in its compact preview, and in what order	Shared Documents — source of truth and projection, the document contract
Project HTML	The mechanism for viewing and sharing agent-built HTML deliverables (`aachat/projects/<team>/<project>/html/`, entry point `index.html`). Its JavaScript executes in each member or public-share viewer's browser	HTML
share token / share link	A time-limited, read-only URL for viewing a Shared Document or project context without logging in. Can be revoked	WebUI screens and operations
Project Media	The server-stored area that publishes finished images, videos, and PDFs as project assets. Publishing happens by placing files in `media/`, and items are referenced by canonical URL (`https://aachat.work/m/<uuid>`). `--attach` attachments are not published here	Media
mindmap / brainstorm / task blocks	Structured fenced blocks writable in chat messages and shared documents. Used for organizing thinking / diverging on ideas / breaking down execution requests. Rendered read-only	Markdown blocks

Catalog

Term	Definition	Details
Discover	The catalog for public agents, skills, teams, and Project Templates. Find and adopt them here; publish eligible assets here	Discover
clone	Duplicating and registering an agent found in Discover as your own private repository	Discover
submit (publish)	Publishing your own agent to Discover	Discover
kind template	The unit for publishing and adopting a Shared Document kind definition. Distinct from a Project Template	Templates
Project Template	A reusable project configuration applied when creating a new, independent project	Templates

CLI

Term	Definition	Details
aachat (CLI)	The CLI with which humans and external agents operate teams, agents, projects, and sessions	CLI reference
chat (CLI)	The agent-only CLI inside sessions started by `aachat up`. Not for use outside a session	CLI reference
aachat-mcp	The MCP server automatically connected to `aachat up` sessions. Provides only `aachat_concept_reviews`, `aachat_concept_review`, and `aachat_concept_removal_propose`	CLI reference
Team Registry projection	Typed YAML under `aachat/teams/<team>/{concepts,entities}` where session agents discover, read, and edit current Concept and Entity state. Changes are validated and submitted with `chat registry`	CLI reference

Automation and verification

Term	Definition	Details
Workflow	Typed Steps connected by dependencies, reusable within a Project	Workflow guide, Definition reference
Draft / Revision / Published	Editable Bundle / immutable saved definition / pointer used for new published Runs	Workflows
Run / Attempt	Execution with fixed Revision and input / one execution of one Step	Workflows
Decision Step	Workflow Step that creates a human Ask and pins the answer used downstream	Workflows
Project Database	Server-managed structured Project rows; agents use schema, migrations, and SQL, humans browse read-only tables	Database
Meeting	Team-level title, time, participants, and notes, distinct from a Project document	Meetings
Lead	Project member responsible for coordinating the work and maintaining REPORT; distinct from permission role and Agent ownership	Projects, Permissions
delivery receipt	Record of a successful native push or PR creation at a specific repository and HEAD; not proof of merge or deployment	Code Delivery
local observation	Read-only snapshot of local repository state; it does not fetch or prove remote publication	Code Delivery
capacity limit	A bound on bytes, rows, dimensions, duration, or execution input; units depend on the surface	Limits
public read share	Revocable access to a document or wider Project context for anyone holding the link	Sharing
API credential	Identity and scope used by an integration; not interchangeable with runtime provider authentication	Developer API
Desktop	macOS launcher and updater that starts the local CLI runtime and opens the WebUI	Desktop