← Back to catalogue
Published

Prompt / Agent Configuration

vr.wm-ai-005 · wm-ai-005-prompt-agent-configuration

Describe, as a format-neutral aggregate, the versioned operational instruction set and tool configuration that governs how an AI model or agent behaves, so that an agent can identify, compose, validate, release, deploy, audit and retire a configuration revision reproducibly.

World Models Information and virtual systems INF.AI.PRM

Bundle → Layer → Finding → Questions Filled

7 bundles · 15 layers · 32 findings · 118 questions

Identity and Release Control How a configuration is named, uniquely addressed, digested, versioned and moved through controlled lifecycle states.

Identity and Addressing

Names, namespaces, aliases and the digest that makes a revision comparable across stores.

Configuration identity and addressing

The identifiers by which this configuration is known: the master-system identifier of record, an ownership-bearing namespaced name, and any unstable display aliases. MCP names are unique only within a server, so they are not global identifiers.

  1. Which authoritative master system issues the identifier for this configuration, and what is that identifier? identity
  2. What governed namespace or reverse-DNS name distinguishes this configuration from a same-named configuration published by someone else? interoperability
  3. Is this a system instruction, a parameterised prompt template, an agent definition, a tool-grant set, or a composite of these? classification
  4. Which display titles, slugs or aliases resolve to this configuration, and which of them are guaranteed stable? definition

Revision integrity and content address

Each released revision is an immutable snapshot identified by an algorithm-qualified digest over a canonical serialisation, with run-time-resolved regions explicitly excluded.

  1. What algorithm-qualified digest identifies the exact content of this configuration revision? evidence
  2. Which canonical serialisation was digested so the same logical configuration yields the same digest in any store? validation
  3. Which regions are excluded from the digest because they resolve only at run time? composition

Configuration kind and intended use

Configurations are not one kind. ISO 22989 treats prompt as overarching generative-AI instructions that may be fixed or editable. MCP treats prompts as user-selected templates and tools as model-controlled functions. OpenAI packages instructions, tools, model settings, guardrails, and handoffs as an agent. Agent Skills packages task expertise separately from the host agent. Classification must record kind, intended task, and whether the payload is public discovery or operational instruction.

  1. Is this payload an instruction stack, a user-selectable prompt template, a skill package, a tool catalog binding, a stored-prompt reference, or a composite agent configuration? classification
  2. What intended purpose, user population, and prohibited uses bound this configuration? definition
  3. Is the prompt fixed by the deployer, editable by operators, or dynamically generated per request, and who may edit it? state
  4. Which fields may appear on a public discovery card versus remaining in the operational instruction body? classification

Versioning and Lifecycle

Version semantics, compatibility declarations, lifecycle states and the change-control record behind each transition.

Version scheme and compatibility

Which version scheme applies, which change classes are breaking for a configuration (authority, grants, output contract, safety constraints), and which interface revisions are declared compatible. Interface revision and artifact version are separate axes.

  1. Which version scheme governs this configuration and what change classes force a major increment? classification
  2. Which consumers pin this configuration by exact revision rather than by a version range? relationship
  3. Which protocol or interface revisions does this configuration declare itself compatible with? interoperability
  4. May a released version be edited in place, and if not, how are corrections issued? constraint

Lifecycle states and change control

The state a revision occupies, the transitions permitted, the approval evidence required to promote it, and the separately recorded instants of authoring, approval, release and withdrawal.

  1. What lifecycle state is this revision in and which states are reachable from it? state
  2. Who must approve promotion to production and on what evidence? decision
  3. When was this revision authored, approved, released and withdrawn, each recorded as a separate instant? temporal
  4. What notice period applies before this configuration is withdrawn from service? lifecycle

External schema alignment and conflicts

This model aligns to ISO 22989 prompt, MCP tools and prompts, A2A AgentSkill, Agent Skills, OpenTelemetry gen_ai.prompt.* and generation attributes, and vendor agent objects. Alignments are not conformance claims. Known conflicts include MCP user-controlled prompts versus developer system instructions, OpenAI provider-system versus industry system-message, OTel date-like version examples, and OpenAI migration away from hosted prompt objects.

  1. Which external schemas is this configuration mapped to, and with what field-level mapping evidence? interoperability
  2. Is any conformance to MCP, A2A, Agent Skills, or OTel actually claimed, and what test evidence supports it? evidence
  3. Which recorded conflicts (prompt control, system-layer meaning, version-as-date, hosted versus repo prompts) affect this instance? decision
  4. Which storage or interface projection carries this instance, without treating that projection as the semantic model? interoperability
Instruction Content and Authority What the configuration actually says, how it is parameterised and rendered, what authority each part carries, and how untrusted content is kept out of the instruction channel.

Instruction Content and Composition

The instruction blocks themselves, their templating surface, and how configurations layer over one another.

Instruction blocks, arguments and rendering

The discrete blocks that make up the instruction payload, their roles and ordering, the named arguments a template accepts, the substitution step that produces final messages, and the escaping that keeps argument values from being read as instructions.

  1. Which discrete instruction blocks make up this configuration and what role does each carry? composition
  2. Which block is delivered to the model as the system or developer instruction before any user input? definition
  3. Which named arguments does this template accept and which of them are required? requirement
  4. What rendering or substitution step turns the template plus arguments into the final message sequence? process
  5. What happens when a required argument is missing or fails schema validation? exception

Composition, overlays and precedence

How this configuration imports or overrides bases, which file wins when several apply to the same working scope, which fragments are shared with other configurations, and how locale or tenant variants are selected.

  1. Which parent or base configurations does this revision import, extend or override? composition
  2. When more than one configuration applies to the same working scope, which one wins? constraint
  3. Which fragments are shared with other configurations and therefore change together? relationship
  4. Which locale, tenant or channel variants exist and how is one selected at run time? classification

Skill packages and progressive disclosure

A skill is a directory with SKILL.md frontmatter (name, description, optional license, compatibility, metadata, experimental allowed-tools) plus optional scripts, references, and assets. Agents load name and description first, then the instruction body on activation, then referenced files on demand. Name must match the directory. This is operational instruction packaging, not the knowledge corpus of the references themselves.

  1. What skill name, description, license, compatibility, and directory identity uniquely identify each bound skill version? identity
  2. Under what conditions is a skill activated, and which instruction body, scripts, and references may then load? process
  3. Does the skill declare experimental allowed-tools, and how is that reconciled with the host configuration allowlist? constraint
  4. Was the skill validated against naming and frontmatter rules, and what validator and result apply? validation

Authority and Trust Boundaries

The precedence of instructions against platform, developer and user levels, and the declared boundary between instructions and untrusted content.

Instruction authority hierarchy

The authority level each block occupies relative to platform, developer and user instructions, which instructions an end user may override, and how equal-authority conflicts resolve. Higher authority overrides lower; developer configuration cannot override platform-level rules.

  1. At which authority level does each instruction block sit relative to platform, developer and user instructions? authority
  2. Which instructions may an end user override and which are non-negotiable for this deployment? constraint
  3. How is a conflict between two instructions of equal authority resolved? decision

Untrusted content boundary and injection defence

Which inbound channels carry no instruction authority, how such content is delimited, what injection testing evidence exists for this revision, and what the runtime does on detection. Tool outputs, retrieved documents and attachments have no authority by default.

  1. Which inbound content channels are declared untrusted and stripped of instruction authority? security
  2. What structural markers separate retrieved or tool-returned content from configuration instructions? constraint
  3. What evidence shows this revision was tested against direct and indirect prompt injection? evidence
  4. What does the runtime do when injected instructions are detected mid-run? event
Capability and Binding Surface What the configuration lets the model do: which model it invokes and how, what it may output, which tools and context it may reach, and which servers, scopes and credentials it binds.

Model Invocation Parameters

Model pinning and preferences, decoding parameters and the declared output contract.

Model selection and preferences

Which model and provider the configuration is pinned to, or the abstract capability priorities and hints used when no exact model is pinned, and what must be re-validated when the model changes beneath a pinned configuration.

  1. Which model and provider is this configuration pinned to, if any? identity
  2. If no exact model is pinned, which capability priorities and hints drive selection? decision
  3. What must be re-validated when the underlying model changes beneath a pinned configuration? validation

Generation parameters and output contract

The decoding parameters the configuration sets, which of them a runtime may silently ignore or clamp, the required output shape, and the schema dialect that governs it.

  1. Which decoding parameters are set and what value does each take? measurement
  2. Which of these parameters may the runtime silently ignore, clamp or reject? exception
  3. What output format does this configuration require and is it enforced by a schema? requirement
  4. Which schema dialect governs the declared output structure? interoperability

Structured outputs, modalities and handoffs

A2A Agent Cards declare default input and output MIME types and skills with examples. OpenAI agents add structured outputs and handoffs with handoffDescription. Configuration must state the output contract and which specialist configurations may be delegated to, without absorbing those specialists' identities.

  1. What structured-output schema or MIME types must responses satisfy, and what happens on violation? constraint
  2. Which default input and output modalities are enabled, and which are overridden per skill? classification
  3. Which other configurations or agents may be handed off to, with what descriptions and constraints? relationship
  4. Which skills are advertised on a discovery card versus only available inside this operational configuration? interoperability

Tool and Context Grants

Which tools the configuration may call, how risky each is declared to be, and what context, roots and memory it may read or write.

Tool grants and schema binding

The named tools the configuration may call, the server each comes from, the input and output schema digests bound at release, disambiguation of colliding names across servers, and explicit denials.

  1. Which named tools may this configuration call and from which server does each come? access
  2. Which input and output schemas were bound to each granted tool at release time? composition
  3. How are collisions between identically named tools from different servers disambiguated? interoperability
  4. Which tools are explicitly denied even when the runtime offers them? constraint

Tool risk annotations and confirmation gates

The behaviour hints attached to granted tools, the basis on which the supplying server is trusted, which calls require human confirmation, and per-tool invocation limits. Annotations must be treated as untrusted unless the server is trusted.

  1. Which granted tools are annotated read-only, destructive, idempotent or open-world? classification
  2. On what basis is the server supplying those annotations treated as trusted? quality
  3. Which tool calls require explicit human confirmation before execution? authority
  4. What invocation or rate limits apply per tool under this configuration? measurement

Context, resource and memory grants

Which resources, roots and knowledge collections may enter context, what context-inclusion mode applies and whether the runtime may narrow it for privacy, and which persistent memory stores the configuration may write to.

  1. Which resources, roots or knowledge collections may be read into context? access
  2. What context-inclusion mode applies and may the runtime narrow it for privacy reasons? privacy
  3. Which persistent memory stores may this configuration write to and with what scope? retention

Server and Credential Bindings

The external servers a configuration connects to, the authorization scopes it requests and how credentials are referenced.

Server bindings and authorization scope

Which servers the configuration binds to and over which transport, which scopes it requests and what justifies each, how credentials are referenced without being embedded, and what happens when a bound server changes its tool list after release.

  1. Which servers does this configuration bind to, at what endpoint and over which transport? relationship
  2. Which authorization scopes are requested and which declared capability justifies each one? authority
  3. How are credentials referenced without being embedded in instruction text? security
  4. What happens when a bound server changes its tool list after this revision was released? event
Safety, Policy and Human Oversight The behavioural constraints the configuration asserts, where they are actually enforced, the secrecy posture of the instruction text, and the human gates and budgets that bound autonomous operation.

Behavioural Policy and Secrecy Posture

Declared constraints, refusal behaviour, enforcement points, and the consequences of instruction text being disclosed.

Behavioural constraints, enforcement and refusals

The behaviours the configuration requires, forbids or conditions; which of them are enforced outside the model at the application or policy layer; and the specified refusal or safe-completion behaviour for out-of-scope requests.

  1. Which behaviours does this configuration require, forbid or make conditional? constraint
  2. Which of those constraints are enforced outside the model rather than by instruction text alone? requirement
  3. What refusal or safe-completion behaviour is specified for out-of-scope requests? process

Secret hygiene and prompt leakage exposure

Whether any instruction block contains a secret, the declared impact of full instruction disclosure, and the independent output inspection that verifies compliance instead of relying on the prompt.

  1. Does any instruction block contain a secret, credential or connection string? security
  2. What is the declared impact if the full instruction text is disclosed to an end user? privacy
  3. Which independent output inspection verifies compliance instead of relying on the prompt? validation

Human Oversight and Autonomy Envelope

Where a human can intervene, what they must be shown, and the hard limits on autonomous operation.

Human oversight and approval gates

Actions requiring a human able to deny them, the information the reviewer must be shown before deciding, the competence and empowerment of the intervening role, and how overrides and denials are recorded.

  1. Which actions require a human in the loop able to deny them? authority
  2. What must be shown to the reviewer before an approval decision is taken? requirement
  3. Which role is competent and empowered to intervene, and how is that competence assured? ownership
  4. How is an override, edit or denial recorded? event

Autonomy limits and resource budgets

The maximum autonomous steps or tool-loop iterations, the token, cost and wall-clock budget bounding a single run, and what terminates an over-budget run and in what state.

  1. What is the maximum number of autonomous steps or tool-loop iterations permitted? constraint
  2. What token, cost and wall-clock budget bounds a single run under this configuration? measurement
  3. What terminates a run that exceeds its budget and what state is left behind? state
Assurance, Evidence and Provenance The evidence that a specific revision behaves acceptably, and the verifiable record of who produced it, from what, and with which dependencies.

Evaluation Evidence

Functional and adversarial evidence produced against a named revision digest, with thresholds and expiry.

Evaluation suites and acceptance criteria

Which suites were run against the exact revision digest, what thresholds gated release, which model build and runtime were used, and how long the evidence stays valid.

  1. Which evaluation suites were run against this exact revision digest? evidence
  2. What acceptance thresholds had to be met before release was permitted? measurement
  3. Which model build and runtime version were used during evaluation? provenance
  4. How long does this evaluation evidence remain valid before it must be repeated? temporal

Adversarial testing evidence

Red-team and adversarial testing performed against the configuration, the attack classes explicitly excluded, and the open findings with their accepted residual risk.

  1. What adversarial or red-team testing was performed against this configuration? evidence
  2. Which attack classes were explicitly out of scope for that testing? exception
  3. Which findings remain open at release and who accepted the residual risk? decision

Provenance and Supply Chain

Who and what produced the revision, and the signed record that lets a consumer verify it before loading.

Authorship and provenance chain

The agents that authored or revised the configuration and on whose behalf they acted, the generating activity and prior entity it derived from, whether any part was machine-generated, and the separation of activity time from record ingestion time.

  1. Which agents authored or revised this configuration and on whose behalf did they act? provenance
  2. Which activity generated this revision and from which prior entity was it derived? relationship
  3. Was any part of this configuration machine-generated, and by which system? quality
  4. When did the authoring activity start and end, as distinct from when the record was ingested? temporal

Release attestation and dependency inventory

The signed statement binding a builder identity to the revision digest, the external parameters and resolved dependencies that produced it, the inventory of models, datasets, tools and third-party prompt components, and the consumer-side verification procedure.

  1. Which signed attestation binds a builder identity to this revision digest? evidence
  2. Which external parameters and resolved dependencies produced the released artifact? composition
  3. Which models, datasets, tools and third-party prompt components does this configuration depend on? interoperability
  4. How does a consumer verify the attestation before loading the configuration? validation
Deployment and Observability Where a revision is actually in force, how exposure is controlled and reversed, and how a run can be traced back to the exact configuration that produced it.

Deployment Binding and Reversal

Active environments, rollout exposure, effective windows, rollback target and immediate-disable mechanism.

Environment binding, rollout and rollback

Which environments and tenants run this revision, the rollout strategy and traffic share, the effective-from and effective-to window per environment, the designated rollback target, and the mechanism that disables the configuration immediately without a redeploy.

  1. In which environments and tenants is this revision currently active? state
  2. What rollout strategy governs exposure and what share of traffic sees this revision? process
  3. From when until when was this revision effective in each environment? temporal
  4. Which prior revision is the designated rollback target? decision
  5. What mechanism disables this configuration immediately without a redeploy? exception

Observability and Run Linkage

The telemetry contract that makes a run attributable to an exact configuration revision, and the privacy rules on capturing instruction text.

Run linkage and telemetry contract

Which telemetry attribute carries the exact revision used by a run, whether instruction text is captured and under what opt-in and redaction rules, and how long run records are kept so the link survives.

  1. Which telemetry attribute carries the exact configuration revision used by a run? interoperability
  2. Are instruction texts recorded in telemetry, and under what opt-in and redaction rules? privacy
  3. How long are run records kept so a run can still be traced back to its configuration? retention
Governance, Compliance and Retention Who is accountable, which regulatory duties attach, who may see the configuration, and how long revisions survive.

Accountability and Regulatory Duties

Ownership, inventory linkage, segregation of duties, risk classification and documentation obligations.

Ownership and accountable roles

Who owns the configuration, who is the accountable deployer, which organisational AI inventory entry records it, and how authoring and approval duties are separated.

  1. Who owns this configuration and who is the accountable deployer? ownership
  2. Which entry in the organisational AI system inventory records this configuration? identity
  3. Which duties are separated so that the author is not the sole approver? authority

Regulatory classification and documentation duties

Whether the system driven by this configuration falls into a regulated risk class, which technical-documentation elements must record the key design choices captured here, and which jurisdictions and effective dates apply.

  1. Does the system driven by this configuration fall into a regulated risk class in any applicable jurisdiction? classification
  2. Which technical-documentation elements must record the key design choices captured here? requirement
  3. Which jurisdictions and effective dates apply to those duties? spatial

Access, Retention and Disclosure

Confidentiality classification, principal rights, redaction for disclosure, and the retention and deletion regime for revisions.

Confidentiality classification and access rights

The confidentiality class of the instruction text, which principals may read, propose, approve or publish, which fields must be redacted before disclosure, and what is logged on read or export. Confidentiality is a handling class, never a security control.

  1. What confidentiality class applies to the instruction text of this configuration? access
  2. Which principals may read, propose, approve or publish revisions of it? authority
  3. Which fields must be redacted before the configuration is shared with a deployer or auditor? privacy
  4. What is logged whenever the configuration is read or exported? security

Retention, deletion and legal hold

How long superseded revisions must be retained for audit and reproducibility, what deletion does and what tombstone survives it, and which holds override the normal period.

  1. How long must superseded revisions be retained to support audit and reproducibility? retention
  2. What deletes a revision and what tombstone survives deletion? lifecycle
  3. Which legal hold or regulatory minimum overrides the normal retention period? exception

Classifiers Filled

Family
World Models
Category
Information and virtual systems
Entry kind
aggregate
Navigation path
NAV.INF.AI.PRM
Domain
INF.AI.PRM
Industry
Cross-industry
Tags
promptagentconfigurationinf.ai.prm

What it is Filled

A Prompt / Agent Configuration is an immutable, versioned, content-addressable specification of agent behaviour. It aggregates instruction blocks (system, developer, template), template arguments and rendering rules, instruction authority levels and trust boundaries, model selection and decoding parameters, output contracts, tool and context/resource grants with risk annotations, server and authorization-scope bindings, safety constraints and human-oversight gates, autonomy and resource budgets, evaluation and adversarial evidence, provenance and release attestation, deployment bindings, and governance metadata (ownership, regulatory classification, access, retention). The model covers the configuration artifact and its lifecycle, not the actor that executes it and not the executions themselves.

In scope

  • Identity, namespacing and content-addressed revision integrity of a configuration
  • Instruction blocks, prompt templates, arguments and rendering/escaping rules
  • Instruction authority hierarchy and untrusted-content trust boundaries
  • Model selection, decoding parameters and declared output contract
  • Tool grants, schema bindings, behaviour annotations and confirmation gates
  • Context, root, resource and persistent-memory grants
  • Server bindings, requested authorization scopes and secret referencing by handle
  • Behavioural constraints, refusal policy and enforcement points outside the model
  • Human oversight gates, autonomy caps and per-run resource budgets
  • Evaluation suites, acceptance thresholds and adversarial-test evidence tied to a digest
  • Authorship provenance, release attestation, signing and dependency inventory
  • Version scheme, compatibility rules, lifecycle states and change control
  • Environment binding, rollout, rollback and immediate-disable mechanisms
  • Ownership, regulatory classification, confidentiality, access and retention

Out of scope

  • The foundation model itself: weights, training data, fine-tuning and adapter artifacts
  • The deployed agent as an actor, its persona in the world, and its runtime process
  • Agent run/execution records, transcripts, traces and conversation content
  • Tool and API implementations, their internal service contracts and hosting
  • Identity and access management principals, credential issuance and secret storage
  • Retrieval corpora, vector index construction and knowledge-base content
  • Multi-agent orchestration topology and inter-agent negotiation protocols
  • Serving infrastructure, hardware, autoscaling and cost accounting systems
  • Content credentials or watermarking applied to generated outputs

Why it exists Filled

Describe, as a format-neutral aggregate, the versioned operational instruction set and tool configuration that governs how an AI model or agent behaves, so that an agent can identify, compose, validate, release, deploy, audit and retire a configuration revision reproducibly.

Distinguishing features Filled

  • A versioned instruction set and tool configuration, not the model it drives or the agent that runs it.
  • Each revision is released, signed and evaluated like a software artefact.
  • Instruction text is guidance only; enforceable constraints live in referenced controls.
  • Unlike a run record, it describes intended behaviour, not what happened.

What robots and AI may and may not do Filled

Must not

  • Place secrets, keys or connection strings in instruction text or variables.
  • Rely on instruction text as a security control.
  • Promote a revision to production without current functional and adversarial evaluation evidence.
  • Grant destructive or open-world tools without a human-in-the-loop path.
  • Approve a revision it authored.

Only with a human decision

  • Approving promotion of a revision to production.
  • Granting destructive or broad-scope tools to a configuration.

May

  • Resolve the effective configuration for a deployment.
  • Render a prompt from a template with declared variables.
  • Validate and evaluate a candidate revision before release.
  • Verify a revision's signature before loading it.

Moral aspects Filled

  • Instructions shape how an agent treats people; hidden changes can introduce bias or deception.
  • Configuration changes can widen data access without users noticing.
  • Reproducibility supports accountability when outputs harm someone.

Who is affected

  • People interacting with configured agents
  • Configuration authors and approvers
  • Operators of deployments

Owners Filled

Steward

The adopting Dimension MUST nominate exactly one authoritative master system for configuration and revision identifiers and publish its base IRI; every other identifier held for the same configuration is recorded as an alias with an explicit stability flag.

Roles

Configuration author
Draft instruction blocks, templates and argument schemas; Declare tool, context and memory grants with a justification for each; Propose the change class and record the rationale for the version increment; Record derivation from prior revisions and disclose any machine-generated content
Release approver
Verify that validation, evaluation and adversarial evidence are complete and unexpired for the exact candidate digest; Approve or reject promotion and record the decision with rationale and timestamp; Confirm segregation of duties, refusing approval where the approver authored the revision; Confirm that a retained, verifiable rollback target exists before production release
Accountable deployer
Determine and record the regulatory risk classification and applicable jurisdictions; Maintain instructions for use and other deployer-facing disclosure extracts; Staff and empower the human oversight function and assure reviewer competence; Own incident response, withdrawal decisions and post-market monitoring linkage
Security reviewer
Assess prompt injection and leakage exposure and sign off the trust boundary declaration; Review scope minimisation, secret-handle hygiene and server binding trust; Maintain the tool risk register and decide whether supplier annotations may be trusted; Set and review confirmation gates and per-tool invocation limits
Evaluation owner
Maintain versioned evaluation and adversarial suites and their acceptance thresholds; Bind every result set to a revision digest and a pinned model build; Set evidence validity periods and trigger re-evaluation on model or runtime change; Publish coverage and exclusions so that assurance claims remain falsifiable
Registry steward
Maintain identifiers, namespaces, aliases and inventory linkage for every configuration; Enforce canonicalisation, digest and serial naming rules across storage projections; Operate the retention schedule, legal holds, tombstones and disposition records; Reconcile the model's alignments when an external standard publishes a new revision

Links to other meta-models Filled

references

  • WM-AI-002 AI Agent - The deployed agent references the exact configuration revision it operates under; agent identity, persona and runtime health remain in the agent model while instruction content, grants and parameters remain here.
  • WM-AI-004 Agent Run / execution record - Each run records the configuration revision identifier and content digest so that behaviour can be reproduced and attributed; only linkage fields cross the boundary.
  • MCP server registry entry (server.json) - Bound servers are referenced by their reverse-DNS registry name and version rather than restated, keeping server packaging and availability outside this model.
  • Credential and secret management model (sibling, not yet registered) - Secret values, vaults, rotation and token issuance are referenced by opaque handle only; embedding secret material in instruction text is prohibited rather than modelled.
  • Foundation model / model card model (sibling) - The pinned model is referenced by identifier and build; training data, architecture, model-level quantitative analysis and model licensing stay with the model card sibling.
  • Evaluation suite and benchmark model (sibling) - Suite definitions, task sets and scoring methodology are referenced; only the binding of results to a revision digest, thresholds and expiry belongs here.

child

  • WM-KNW-005 parent knowledge model - Inherits identity, provenance, access and retention semantics for a governed knowledge artifact, and adds executable operational semantics that a passive knowledge asset does not carry.

aligned

  • Model Context Protocol tool and prompt definitions - Field-level alignment for prompt arguments, tool name, input and output schema, behaviour annotations and capability declaration; alignment only, no conformance claimed.
  • Semantic Versioning 2.0.0 - Supplies the version precedence and release-immutability rules used for configuration revisions; the breaking-change classes are model-specific and are not part of the standard.
  • W3C PROV-O - Provides the vocabulary for authorship, delegation, generation and derivation of configuration revisions, including the separation of activity time from record time.
  • SLSA Provenance / in-toto attestation - Supplies the attestation shape binding builder identity, external parameters and resolved dependencies to a subject digest for released configuration revisions.
  • CycloneDX ML-BOM (ECMA-424) - Target format for the configuration's dependency inventory of models, datasets, tools and third-party prompt components.
  • OpenTelemetry generative-AI semantic conventions - Maps configuration facets to telemetry attribute keys so runs can be attributed to a revision; attributes are at development stability, so the alignment is explicitly provisional.
  • OpenAI Model Spec chain of command - Supplies the authority ordering and the default rule that tool output, quoted text and attachments carry no instruction authority; adopted as an alignment, not a conformance claim.
  • Regulation (EU) 2024/1689 technical documentation and transparency duties - Maps configuration fields to documentation, logging, information-to-deployer and human-oversight obligations where the driven system falls into a regulated class; applicability is asserted per deployment, never by default.
  • NIST AI RMF AI system inventory and change management - Links each configuration to an organisational inventory entry and to documented change-management, testing and third-party policy expectations.

extends

  • AGENTS.md bootstrap convention - Extends the plain-Markdown, nearest-file-wins convention with the mandatory Vercy bootstrap fields, so an agent can discover the specification, storage, interface and process endpoints from the package root.

neighbor

  • WM-AI-002 AI Agent (deployed actor) - This model is the versioned instruction artifact; the agent model is the actor that loads it. The agent references a configuration revision; the configuration never contains agent runtime state, health or persona-in-world facts. One configuration may be referenced by many agents and one agent may swap configurations over time.
  • WM-AI-004 Agent Run / execution record - A run records the exact configuration revision identifier and digest for reproducibility. Only linkage fields (revision reference, telemetry attribute keys, conversation identifier) belong here; prompts, tool call payloads, outputs and timings of a specific execution belong to the run model.
  • WM-KNW-005 parent knowledge model - The configuration is a governed knowledge artifact and inherits identity, provenance and retention semantics, but adds executable operational semantics: authority levels, capability grants and enforcement points that a passive knowledge asset does not have.
  • Foundation model / model card artifact - The configuration records which model it is pinned to and which decoding parameters it sets; it does not describe training data, architecture, quantitative model-level analysis or model licensing. Those belong to a model-card style sibling aligned with CycloneDX ML-BOM.
  • Tool / MCP server definition - The configuration records the grant (which tool name, from which server, bound to which schema digest, with which confirmation gate). The tool's own definition, implementation, availability and versioning are owned by the server and its registry entry. Tool annotations are copied as untrusted claims, not as authoritative classification.
  • Credential and secret management model - The configuration holds only opaque secret handles and requested authorization scopes. Secret values, rotation, vault policy and token issuance are out of scope; embedding a secret in instruction text is prohibited by policy rather than modelled here.
  • Software build / release artifact - The configuration borrows release semantics (immutability, semantic versioning, in-toto/SLSA attestation) but is not a code build: its externalParameters are instruction text and grants, and its correctness evidence is behavioural evaluation rather than compilation.

parent

  • WM-KNW-005

What else AI and robots need to interact with it Filled

Identity and identifiers required Filled

  • Authoritative master-system identifier issued by the configuration registry of record, that is, the system that owns the configuration's lifecycle and is the single source of truth for its identity.
  • Governed global identifier or IRI, such as a reverse-DNS namespaced configuration name whose namespace ownership is verifiable and which resolves to a published manifest.
  • UUID or ULID minted by the adopting Dimension, used only when neither a master-system identifier nor a governed global identifier exists, and recorded as Dimension-local.

Direct properties not applicable Not applicable

Not applicable

Institutional or informational subject: no invented physical properties.

Recognition optional Filled

  • A configuration revision has an identifier, version, instruction text or template, tool grants, model binding and signature.
  • Often confused with the model, the deployed agent, a run transcript and a tool server definition.

Capabilities and actions required Filled

  • Resolve effective configuration: Combine a base revision with its overlays, variants and scope-specific configurations into a single effective view, emitting the precedence trace that justifies every resolved field.
  • Render prompt from template: Substitute validated argument values into a prompt template to produce the final message sequence, applying escaping so that values cannot be read as instructions.
  • Validate configuration revision: Check a candidate revision against its structural schema, declared policy rules and internal consistency, including that no secret appears in instruction text and that every requested scope has a justification.
  • Release configuration revision: Freeze an approved candidate into an immutable revision, mint its canonical digest, assign a version according to the declared change class, and emit the release event.
  • Attest and sign revision: Produce a signed provenance statement binding the builder identity, external parameters and resolved dependencies to the released revision digest, together with a component inventory.
  • Verify configuration before load: Verify digest and signature against declared trust anchors before a runtime loads a configuration, and classify accompanying tool annotations as trusted or untrusted based on the verification result.
  • Evaluate configuration revision: Run functional and adversarial evaluation suites against a specific revision digest under a pinned model build, compare results with acceptance thresholds and attach the evidence with an expiry.
  • Bind revision and control rollout: Activate a verified revision in a named environment or tenant under a declared rollout strategy, opening a new binding record and closing the previous one with an effective-to instant.
  • Roll back or disable configuration: Withdraw an active revision immediately, either by reverting to the designated rollback target or by disabling the configuration without a redeploy, and link the action to an incident record.
  • Redact configuration for disclosure: Produce an audience-appropriate disclosure package from a revision, applying the declared redaction rules while preserving verifiable linkage to the original digest.
  • Bind tools and skills: Attach a pinned tool catalog and skill packages, reconcile experimental allowed-tools with the host allowlist, and record independent risk classes.
  • Pin configuration for a run: Emit the pin tuple a run must store so later inspection can recover the exact instruction and tool package.

Hazards and failure modes required Filled

  • Secrets leaked through prompt text.
  • Prompt injection exploiting weak instructions.
  • Unreviewed tool grants causing destructive actions.
  • Silent behaviour change from unversioned edits.

Standards and interfaces required Filled

  • Model Context Protocol tool definitions.
  • JSON Schema for variable and tool parameter schemas.
  • Semantic Versioning for revisions.
  • Sigstore and in-toto for signing and attestation.

Context of use required Filled

  • Regulatory structure is drawn from Regulation (EU) 2024/1689 as described by the European Commission and assumes placement on the market or use within the European Union; dates cited are the Commission's published timeline.
  • No obligations from United States federal or state law, United Kingdom, Chinese, Japanese, Indian, Brazilian or sector-specific regimes are asserted; adopters in those jurisdictions must add their own documentation and record-keeping duties.
  • NIST AI RMF is treated as voluntary guidance, not as a legal requirement in any jurisdiction.
  • Language and locale variants are assumed optional; a monolingual configuration is valid under this model.
  • Data residency and cross-border transfer constraints on stored revisions and access logs are delegated to the storage projection and are not modelled here.
  • NIST AI 600-1 is voluntary US federal guidance; it is used for risk actions, not as a global legal duty.
  • ISO/IEC 22989 prompt text cited here is from Amendment 1 draft excerpt (DAmd 1), not proven as already in ISO/IEC 22989:2022 without the amendment.
  • OpenAI Model Spec localization and legal-compliance variants imply some deployments will have locale-specific provider-system layers.
  • EU, UK, and other high-risk AI documentation duties may require retaining instruction versions even when this model would otherwise allow deletion; treat as a hold overlay until a primary mapping is added.

Sources Filled

  1. Model Context Protocol Specification — Tools - Model Context Protocol project
  2. Model Context Protocol Specification — Prompts - Model Context Protocol project
  3. Model Context Protocol — Versioning - Model Context Protocol project
  4. Model Context Protocol — Security Best Practices - Model Context Protocol project
  5. Model Context Protocol Specification — Sampling - Model Context Protocol project
  6. OpenAI Model Spec - OpenAI
  7. NIST AI Risk Management Framework Playbook — GOVERN - National Institute of Standards and Technology (NIST)
  8. PROV-O: The PROV Ontology - World Wide Web Consortium (W3C)
  9. Semantic Versioning 2.0.0 - Semantic Versioning project
  10. RFC 3339 — Date and Time on the Internet: Timestamps - Internet Engineering Task Force (IETF)
  11. SLSA Provenance (predicate specification) - OpenSSF / SLSA project
  12. CycloneDX Machine Learning Bill of Materials (ML-BOM) - OWASP Foundation / CycloneDX (ECMA-424)
  13. AGENTS.md — an open format for guiding coding agents - AGENTS.md community project
  14. Regulatory framework for AI (Regulation (EU) 2024/1689) - European Commission, Directorate-General for Communications Networks, Content and Technology
  15. EU AI Act Article 13 — Transparency and provision of information to deployers - Future of Life Institute (AI Act Explorer reproduction)
  16. OpenTelemetry Semantic Conventions — GenAI attribute registry - OpenTelemetry (Cloud Native Computing Foundation)
  17. MCP Registry — generic server.json reference - Model Context Protocol project
  18. OWASP Top 10 for Large Language Model Applications - OWASP Foundation
  19. JSON Schema 2020-12 release notes - JSON Schema organisation
  20. ISO/IEC 22989:2022/DAmd 1 Information technology — Artificial intelligence — Concepts and terminology — Amendment 1: Generative AI - ISO/IEC JTC 1/SC 42
  21. Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile (NIST AI 600-1) - National Institute of Standards and Technology (NIST)
  22. Semantic conventions for generative client AI spans - OpenTelemetry / CNCF
  23. Model Context Protocol — Tools - Model Context Protocol project
  24. Agent Skills Specification - Agent Skills (open standard originated by Anthropic)
  25. Agent2Agent (A2A) Protocol Specification, Version 1.0 - A2A Project, Linux Foundation
  26. OpenAI Model Spec - OpenAI
  27. OpenAI API — Agent definitions and stored prompts - OpenAI
  28. OWASP Top 10 for LLM Applications 2025 - OWASP Foundation
  29. Safety system messages — Azure OpenAI in Azure AI Foundry Models - Microsoft
  30. Agent Registry JSON schemas (A2A Agent Card and MCP tool schema) - Google Cloud
  31. ISO/IEC 42001:2023 Information technology — Artificial intelligence — Management system - ISO/IEC JTC 1/SC 42
  32. Model Context Protocol schema — Tool and ToolAnnotations - Model Context Protocol project

Open questions

  • Guardrail fail-mode semantics: whether a bound guardrail fails closed, fails open or escalates to a human, and whether that decision is logged — currently only vendor documentation supports it.
  • Effective-stack digest after substitution as distinct from the unevaluated template digest, and the context-budget truncation policy that decides what is dropped first and whether the drop is recorded.
  • Vendor-hosted stored-prompt objects (id, version, variables) and the migration path toward application-owned source, to confirm this is a storage projection rather than a second semantics.
  • Request-time computed instructions: which function, inputs and non-model local context may shape instruction text, and how a dynamically computed stack is pinned for replay.
  • Static-instruction token or character budgeting so instructions do not starve task context, and whether any primary source governs it.
  • EU AI Act Annex IV mapping of prompt and configuration artifacts as high-risk technical documentation, fetched as a primary source rather than via a reproduction site.
  • Prompt A/B experimentation, canary traffic splitting and automatic prompt optimisation (DSPy and similar) — currently no primary standard, so generated text is treated as a versioned payload only.
  • Determinism: how a sampling seed is combined with the configuration digest for reproducible runs without the seed ever becoming part of identity.
  • Internationalisation governance: translation equivalence, review of localised instruction text, and whether evaluation evidence for one locale transfers to another.
  • Model weights, fine-tuning runs, adapters and distillation artifacts, which belong to a model-card sibling.
  • Retrieval corpus construction, chunking and vector index configuration beyond the grant reference.
  • Multi-agent orchestration topology, delegation graphs and inter-agent protocols.
  • Internal design of guardrail classifiers and output inspection models.
  • Commercial licensing, pricing and intellectual property terms attaching to prompt assets.
  • Content credentials or watermarking applied to generated outputs.
  • Accessibility and human-factors requirements for the oversight review interface.
  • ISO/IEC 42001 Annex A control mapping: iso.org returned HTTP 403 during this session, so no ISO control identifiers are cited and no ISO alignment is asserted.
  • NIST AI 600-1 Generative AI Profile action identifiers: the published PDF could not be parsed to text in this session, so only the NIST AI RMF Playbook GOVERN subcategories are cited.
  • OWASP Top 10 for LLM Applications 2025 entry text: the 2025 PDF exceeded the fetch size limit, so only the OWASP project page and its archived 2023 list were directly verified and the 2025 entry numbering is not asserted.
  • EU AI Act Annex IV mapping of prompts as high-risk technical documentation was not fetched as a primary source and is a likely regional omission.
  • Prompt A/B experimentation, canary traffic splitting, and automatic prompt optimization (DSPy and similar) lack a primary standard and are not modeled as first-class objects.
  • IEEE or other SDO prompt-markup languages (PromptML, POML) were not located as adopted standards in this pass.
  • MCP specification has moved beyond 2025-06-18 (schema 2026-07-28 observed); hosts may implement later prompt or tool fields not fully decomposed here.
  • Provider-specific cache breakpoints, prompt-caching billing, and multimodal system-prompt part inventories beyond MCP image/audio examples are incomplete.
  • National adoptions of ISO/IEC 42001 (for example documented operational-instruction lists) were seen only in translation and are not treated as ISO-canonical clause text.
  • LangChain Hub, PromptLayer, and other commercial prompt registries are vendor implementations, not semantic sources.

Machine files

Provenance

world-models research · reviewable-draft

Built from: models/wm-ai-005-prompt-agent-configuration/spec.yaml, ver-cy/world-models/card-supplements/wm-ai-005-prompt-agent-configuration.json