Master Glossary

Layer terms (v1 vocabulary, still valid)

Environment layer. The business-blind machinery every engagement runs on: agent harness plus platform infrastructure. Test: if its operator has to ask “what does PE mean?”, the layering has failed. It builds slots; it never fills them.

Industry ontology. The versioned, client-agnostic knowledge asset: concepts, relationships, documents, capabilities and declared business rules true across PE firms. Read-only and version-pinned from above. Never contains instructions or orchestration.

Solution layer. Where agents, workflows, copilots, skills and the domain library live. References the ontology by ID; configured per client by the binding.

Client binding. Everything true for exactly one engagement: tenant configuration, connections, gate names and approvers, stage mappings, orchestration choices, overlays. One binding file per engagement.

Platform layers, v2 model (Experience → Environment)

Experience layer (L1). Ambient, conversational, cross-channel delivery across every channel a client asks for: chat, web app, desktop, mobile app, voice, phone and call center, embedded work tools, and MCP hosts, one conversation following the user across channels. Channels, formats and templates are parameters; every user reaction routes to the eval store.

Knowledge layer (L3). Client-blind, versioned releases only. Three shelves: industry ontologies, functional ontologies, P1Z benchmarks. Declares what is true, never how to act. Benchmarks are fed only through the promotion gate and curated consulting priors.

Intelligence layer (L4). The AI layer: foundation models, small language models, embeddings, rerankers, model router. Thin, vendor-agnostic, entirely behind the portability boundary. Reasoning is rented, not owned; the layer absorbs model progress so nothing above it changes.

Data & documents layer (L6). Per-tenant data stores (vector, document, SQL/warehouse), retrieval APIs, indexing and taxonomy enforcement. Client data lives here and only here; stores are reusable templates, the client's instances are plane-side. Data-engineering skillset.

Integration layer (L5). The movement machinery, split from storage because technology and skillset differ: connector library (a P1Z asset that compounds per engagement), sync engine, schema-mapping toolkit, pipeline templates. The most client-weighted layer, sources, credentials, field mappings, schedules are all plane values. A missing connector is built into the library, never as engagement code. Middleware: every agent tool call and outbound API call enters at its MCP/API gateways. Environment is L7.

Client plane. The vertical layer spanning L1–L7: the only per-client build. PLAN (EA-shaped assessment whose deliverable is the filled binding) → RUN (HITL configuration, overrides, constraints, operations). No code in the plane, values only; custom logic is built in the Solution layer as an overlay and selected here.

Operational loop. The environment learning how to run: traces, cost, latency and eval trends optimizing routing, dispatch, compaction. Business-blind; every tuning lands as a versioned config change through CI, silent drift is a defect.

Knowledge loop. P1Z learning what is true: engagement telemetry and eval outcomes flowing through the promotion gate into versioned Knowledge releases. Never crosses the operational loop.

Promotion gate. The mandatory pipeline for telemetry entering the Knowledge layer: anonymize → aggregate → contractual-rights check → human review → versioned release.

Sandbox environment. An ADLC construct, not an architecture component: isolated workspace, relaxed gates, fake data, auto-expiry, prototyping happens inside the platform. Exit only through the promotion checklist.

ADLC (agent development life cycle). Design (spec + ADR) → build in sandbox → eval gate → promotion checklist (ADR + passing eval + second occurrence for shared assets) → registry-only deploy → operate → optimize (versioned) → retire (deprecate, never delete).

SSRA (Skills, Scripts, References, Assets). The four directories of an Agent Skill, used here as the name for the whole file grammar of an engagement: how every layer manifests as files. SKILL.md carries the procedure, scripts/ the deterministic steps, references/ the documents loaded on demand, assets/ the output templates. Sources get servers, repos get constitutions, use cases get skills, and hosts get the north gateway. The skeleton is L7 scaffolding; each client's filled files are generated from plane values. A new use case adds one skill file; a new client adds one binding.

MCP host. The application the user sits in (Claude Desktop, Copilot, a custom app). Client-side, at the top of the Experience layer; P1Z never builds the host, it serves hosts.

Client surface shell. A P1Z-built surface: web app, desktop shell (native plus webview), mobile, or voice client. Thin by rule: a shell renders and captures, holds no business logic, and speaks to the platform only through the north gateway. Distinct from a third-party MCP host, which P1Z never builds.

Omnichannel by default. Cross-channel continuity as a standing platform capability, never a client option: one conversation follows the person across every activated channel, with the session keyed to the person and every channel adapter attaching through the north gateway. Clients choose which channels are on; they cannot create per-channel silos.

Shared UI core. The single presentation package every P1Z-built shell reuses: the render tree, streaming message views, and the conversation state machine. One package, many shells; a new surface is a new thin shell over the same core, never a re-implementation.

North-facing Platform MCP Gateway. The platform exposed as an MCP SERVER to any host: agents, use cases and UI resources offered as tools; the entire codebase and business logic stays server-hosted. Carries tenant identity and person identity: per-tenant endpoint, tenant auth, host allow-list, per-user identity passthrough, rate limits and per-host quotas.

South-facing MCP tool servers. The Integration layer's tool servers, where the platform acts as MCP CLIENT toward data: one server per source, permissions once per server. A different security plane from the north gateway, never merged.

A2A (agent-to-agent protocol). A protocol for agents calling other agents directly, distinct from MCP's host-to-server model. In this architecture any A2A-exposed specialist agent is wrapped behind the north gateway so tenant auth, the host allow-list and identity passthrough still apply; A2A never becomes an ungoverned third boundary.

Determination rule. Any task with a testable right answer is deterministic code; agents get judgment only. Four tests, any yes means code: exact-output unit test possible; two professionals always agree; must run identically; failure machine-detectable. An agent is the last resort, not the first draft.

Engineering disciplines (environment layer)

Harness engineering. Everything around the model that turns model calls into a reliable agent: the agent loop and its stopping and budget enforcement, tool dispatch and MCP machinery, model routing, context assembly and compaction, memory, sandboxing, guardrail enforcement, verification runners, trace and eval infrastructure. “A harness is every piece of code, configuration, and execution logic that isn’t the model itself”, Agent = Model + Harness.

Platform engineering. The classical infrastructure half: cloud accounts and networking, identity and tenancy provisioning, CI/CD and repo scaffolding, secrets and keys, data-pipeline plumbing, storage lifecycle, SRE operations, release mechanics.

Managed agent runtime. A vendor-operated agent harness consumed as a service: the agent loop, sandbox, tool execution and session persistence run on managed infrastructure. Current offerings: Anthropic Managed Agents (beta), AWS AgentCore Runtime, Azure AI Foundry Agent Service, Google Vertex AI Agent Engine. A buy-versus-build choice for the runtime slice of L7; the standing rule is that the harness choice must never constrain the model choice.

The boundary between the two. Harness owns everything that executes per agent run; platform owns everything that exists before and around runs. Both business-blind. Neither authors content, the harness builds the slots; the layers above fill them.

Data governance & rendering terms

Source authority weighting. When sources disagree, a versioned authority policy decides which value wins, deterministic code, never agent judgment. The policy is Knowledge content; the domain rule library enforces it.

Canonical record. The single reconciled record downstream steps read: resolved values with source lineage attached. Produced by authority weighting; a value outside the canonical record is not citable.

Source catalog. The machine-readable registry of sources: what exists, where it lives, what schema and access rules apply. Agents consult it before reaching for data. Populated from the plane's source-estate inventory; operated in the Integration layer.

Restricted store. A walled source repository excluded from every shared index and pipeline, reachable only through entitlement-checked retrieval. Which stores are restricted is a plane value; the wall itself is harness machinery.

Scoped index lifecycle. Per-engagement retrieval indexes are created when a case opens and destroyed when it closes. A derived index never outlives the entitlements of the data it was built from.

Identity passthrough. The requesting person's identity travels through the north gateway with every request, so downstream permission checks act as the person, never as the platform.

Deterministic rendering boundary. A deliverable is a pure function of an immutable, versioned template and approved structured data. Agents produce structured content only; corrections land as data updates and the artifact regenerates, output is never hand-edited.

Delivery playbook terms

Mini-output. The bounded, independently reviewable piece of a deliverable that one agent owes per its run contract: a section, a reconciled table, a cited analysis. Only the orchestrator assembles mini-outputs into the final deliverable, through the deterministic rendering boundary. No single agent ever writes the final artifact.

Ontology triage. The three-way classification applied to every business finding during discovery: consistent with the industry ontology (truth, adopted as is), varies by firm (an overlay candidate), or contradicts the ontology (recorded as a conscious business-model decision on the Decision Register). Nothing forks silently.

Ontology overlay. A versioned, domain-specific or function-specific extension layered on top of the industry ontology without modifying it; selected per engagement through the plane.

Loop engineering. Regenerating an agent's output against its eval verdict until it passes or escalates, bounded by the run contract's budget. The eval defines quality; the loop enforces it; a person is the escape path, never an unbounded retry.

PRD written as an eval. The playbook's requirement discipline: every product requirement is stated as a measurable evaluation with golden exemplars and target thresholds. A requirement that cannot be evaluated is not yet a requirement.

Actor terms

Agent. A governable solution-layer unit that owns a business outcome, performs open-ended judgment work under guardrails, and faces human gates. Permissions, evaluations and gates attach here and only here.

Subagent. A worker inside one agent’s boundary (orchestrator-workers pattern). Inherits the parent’s context, reports through a bounded summary contract, never faces a gate directly.

Orchestrator. The routing and control unit above all agents: validates inputs, dispatches, enforces gates, sequences the dependency graph, records lineage. Deterministic core; never produces business content.

Workflow. Deterministic multi-step logic on predefined code paths. No open-ended judgment; not an agent.

Copilot. Interactive assistance inside a human’s own working session. The human drives; nothing runs unattended; no gates.

Asset terms

Project. One client engagement in its entirety. A use case is never a project.

Use case. One business outcome delivered end-to-end. Owns exactly one skill; implemented as an agent, workflow, or copilot per the determination rule.

Skill (SKILL.md). The single file carrying one use case’s specific logic, loaded only when that use case runs.

Constitution (CLAUDE.md). The always-loaded rules file, the file Anthropic's docs call project memory; constitution is our house name for it. Contains only content that applies to every use case in its project. One per client project, plus one root constitution for coding standards.

Binding. The per-engagement configuration file instantiating the client plane.

Context pack. The just-in-time slice of knowledge and client data assembled for one dispatched task. Contents defined by the Knowledge layer and the binding; delivery mechanics owned by the harness.

Domain rule library. The shared, CI-verified code that implements rules the Knowledge layer declares; exposed to agents as thin tools. Rules are never implemented a second time elsewhere.

Golden exemplar. A reference output evaluations score against. Knowledge-layer content, executed by harness-owned eval infrastructure.

Run contract. The declaration every agentic loop makes before running: its end state (machine-checkable) and its token budget. Enforced by the harness; authored by the use case.

Gate (human approval gate). A state transition that cannot occur without recorded human approval. Which gates exist and who approves is plane content; the blocking mechanics are harness content.