Domain glossary

This page fixes the canonical vocabulary of the product domain. Each entry gives a definition and the words that should not be used instead — those usually arrive as habits carried over from another system, and mixing them in blurs the discussion exactly where precision matters.

Organization and scope

Organization The single enterprise and team governance boundary in one deployment. A deployment has exactly one Organization, which may contain several Workspaces.

Avoid: tenant, customer account, organisation switcher, cross-organisation membership.

User A human member with a stable identity inside the single Organization. A member cannot join or switch to another Organization.

Avoid: global cross-organisation account, tenant user.

Workspace The logical collaboration scope inside the Organization that carries membership authorisation and shared capabilities.

Avoid: project, repository group.

Project A long-lived scope inside a Workspace that organises repositories, tasks, knowledge and decisions around one sustained engineering goal.

Avoid: repository, task collection.

Repository One independently versioned codebase associated with a project.

Avoid: project, workspace.

Execution

Task One work instance that executes an R&D goal against frozen inputs.

Avoid: project, job history.

TaskSpec The set of inputs and versions resolved before task creation and immutable while it runs.

Avoid: task context, runtime state.

Flow A reusable R&D process asset maintained by a user or by the platform. Its definition describes node invocations, dependencies and data contracts; the dependency graph is a visual projection of that same content.

Avoid: visual-only flowchart, canvas document.

WorkNode A reusable agent execution definition that can be maintained and versioned independently.

Avoid: flow invocation, node position in a graph.

Flow Invocation One work node invocation inside a flow, carrying a node identifier, dependencies, input bindings, outputs and artefact routing.

Avoid: work node, standalone task.

Attempt One immutable execution version of a work node. A successful attempt freezes its artefacts.

Avoid: retry count, task rerun.

Sandbox The isolated runtime boundary of one task. One task corresponds to one sandbox.

Avoid: container, pod, runtime environment pool.

Execution Generation The identifier of a new execution sequence created by one resume action. Cancellation acceptance, process exit, durable terminal state and business success are distinct facts.

Avoid: restart, rollback.

Handoff and delivery

Artefact Data formally handed off between nodes. Identified by name, path, size and digest. A downstream node cannot modify an upstream version.

Avoid: output file, temporary file, build output directory.

Unit Gate A deterministic check command declared by the user on a work node, judged by its exit code.

Avoid: test suite, CI step.

AgentExecutionManifest The single execution configuration of a task, secret-free and digests fixed, containing the repository, the requirement source locations and the complete execution definition of every node.

Avoid: collection of configuration files, runtime configuration.

Code Change Artefact The immutable code change produced by one invocation, identifying the repository it belongs to, the starting code version, the result version and the originating attempt.

Avoid: working tree directory, moved branch pointer.

Knowledge and memory

Knowledge Formal cognition that is synthesised within an explicit scope, reusable and sourced.

Avoid: raw material, conversation transcript, retrieval result.

Knowledge Space A body of knowledge with its own authoritative source, version history and access boundary. Split into repository knowledge and project knowledge.

Avoid: search index, vector database.

Decision A special kind of knowledge, confirmed by a person, that changes a project's direction, constraints or trade-offs.

Avoid: agent inference, chat message.

Source Raw evidence that can support or contradict a piece of cognition — code, a document, an artefact, an interaction, a commit or a change request.

Avoid: knowledge, memory.

Memory The ongoing mechanism that captures, consolidates, recalls and forgets cognition out of execution.

Avoid: session archive, task log, knowledge record.

Memory Snapshot An immutable, verifiable projection of the configuration and memory revisions one turn or task actually consumed.

Avoid: live memory, latest configuration.

Memory Contribution Memory evidence and source references submitted by a successful task through a version-constrained structured artefact. The subject, the task, the execution generation, the status and the revision are bound by the control plane.

Avoid: writing to memory directly, task log.

Working Memory Situational summaries, observations, decisions or open items confined to one conversation or task, carrying an expiry and traceable to their sources.

Avoid: prompt buffer, conversation archive.

Semantic Memory Experience or factual cognition a user can reuse across conversations, requiring an explicit authoritative state.

Avoid: project knowledge, raw fragment, vector.

Resident Memory User identity, goals, preferences, behavioural rules and agent configuration that reside in context by default within the context budget.

Avoid: system policy, task instruction, project knowledge.

Capability supply chain

Marketplace Asset A flow, node, skill or extension with a stable identity, a single editable authority and a continuous release history.

Avoid: per-scope copy, catalogue card, installation state, runtime selection.

Asset Promotion A one-way promotion that creates the release at the target tier, migrates asset authority and closes the old scope's write entry in a single atomic state transition.

Avoid: copy, installation, publishing an image.

Skill A set of versioned instructions, reference material, scripts and supporting files that an agent can assemble and use.

Avoid: prompt, installed runtime dependency.

Skill Release An immutable version formed from a deterministic package that passed package contract validation.

Avoid: draft, live Git path.

Capability Visibility The discoverable-and-usable relation between one release and the current invoking principal. Once live authorisation passes, the capability enters the execution capability set directly, with no extra installation, subscription, copy or binding required.

Avoid: installation, subscription, personal favourite, user-installed flag.

User Runtime Credential A member's private authorisation for Git, a model gateway, an extension or an external connector. A Workspace only constrains which resources and capabilities that credential may reach; it cannot own, copy or persist a personal secret.

Avoid: workspace credential, capability visibility, marketplace asset.

Organization and roles

Platform Assistant A deployment-level platform AI assistant for all authorised members. It explains the platform, queries state, forms proposals and bridges to governed execution entry points, but does not carry out a user's R&D work itself.

Avoid: workspace-owned agent, task agent, execution agent.

Personal Development Environment A member's single personal development machine runtime identity in the current deployment. It can start, stop or exit on idle, but those run states do not change its persistent workspace identity.

Avoid: workspace machine, one-off task sandbox.

Managed Development Service A standard capability entry point that the platform provides and governs inside a personal development environment, with a stable service identity, an access scope and an independent health state.

Avoid: open port, container port, auto-discovered port.

Development Port Forward An authorisation relation a member creates explicitly, mapping a user application service inside their personal development machine to a governed access entry point.

Avoid: port open by default, automatic exposure.