AI Run Declaration

Definition

The phrase “based on its declared execution” in the Formal Definition of AI Identity Protocol points to a specific concept: the AI run declaration. A declaration is the complete specification of an AI run’s execution parameters before execution begins. It is the fixed, canonical input from which Deterministic Identity is computed.

A declaration consists of every parameter that defines the execution: the model, the prompt, the configuration parameters, the context, and the constraints. Together, these elements constitute the AI run as a composite execution. No single element is sufficient. The declaration is the totality.

The declaration is what makes identity deterministic. Because the declaration is fixed before execution begins, the identity derived from it is stable and independently verifiable. Any party with access to the same declaration computes the same identity. The declaration is the anchor that prevents identity from drifting into ambiguity.

The Core Problem

AI systems today execute runs without declarations. A request arrives, a model processes it, and a response departs. The execution parameters exist momentarily in system memory, then disperse across logs, caches, and internal state. No single, authoritative specification of what was executed persists.

This absence creates the fundamental identity problem described in Why AI Systems Lack Identity. Without a declaration, identity has no fixed input. Without a fixed input, identity is not deterministic. Without deterministic identity, no system verifies, reproduces, or agrees on which execution occurred.

The absence of declarations is not a missing feature in existing tools. It is a missing concept in how AI executions are understood. Current infrastructure treats each run as a transient event rather than a declared, identifiable execution. The AI run as a composite execution is invisible to systems that never formalize what the run consists of.

Failure Modes

Without formal declarations, AI systems encounter failures that no amount of tooling resolves:

1. Parameter scatter. The elements of an AI run’s execution are distributed across different systems. The prompt is in the application layer. The model version is in the deployment configuration. The temperature setting is in an API call. No single record captures the complete execution specification. Reconstructing the full set of parameters after the fact is unreliable and incomplete.
2. Declaration drift. Between the moment parameters are specified and the moment execution completes, system state changes. Model weights update. Context windows shift. Default parameters change between API versions. Without a declaration that freezes the specification at a point in time, the parameters that defined the run become uncertain.
3. Reconstruction failure. After an AI run completes, teams attempt to determine what was executed by examining logs, outputs, and system configuration. Identity cannot be reconstructed from these artifacts because they are incomplete, mutable, and system-specific. As explained in Identity vs Reconstruction, reconstruction is not a substitute for declaration.
4. Partial specification. A record captures some execution parameters but not all. The prompt is recorded, but the system prompt is omitted. The model name is logged, but the specific version is not. Partial specifications produce partial identities. A partial identity is not an identity because it does not uniquely and deterministically identify the run.
5. Implicit parameter dependency. Many execution parameters are implicit: default values, inherited context, system-level configurations. These implicit parameters affect execution but are never formally declared. The run’s identity is incomplete because it is based on an incomplete specification of what was executed.

Why Existing Approaches Fail

Every existing approach to tracking AI executions fails because none of them produce or require formal declarations.

Logs

Logs capture events that occurred during execution. They are retrospective, partial, and system-specific. A log entry records what was observed, not what was declared. Two logging systems produce different records of the same execution. Logs are evidence of what happened, not a specification of what was intended. A declaration precedes execution; a log follows it. These are fundamentally different temporal positions with different epistemological roles.

Observability

Observability platforms aggregate signals from running systems to provide visibility into behavior. They instrument execution to collect metrics, traces, and logs. This instrumentation captures aspects of how execution proceeded, not the complete specification of what was declared. Observability is retrospective analysis of system behavior, not prospective specification of execution parameters. It monitors what is happening but never specifies what was declared.

Tracing

Distributed tracing tracks request paths through service architectures. Traces document the journey of a request, not the declaration of an AI run. A trace shows which services were called and in what order, but it does not capture the complete execution parameters that define the AI run as a composite execution. Tracing answers “where did this request go” but not “what execution was declared.”

Outputs

Outputs are the consequences of execution, not its specification. Using outputs to infer what was declared reverses the causal relationship. Identity is not derived from outputs because outputs are produced by execution, and execution is defined by declaration. Multiple different declarations produce identical outputs. A single declaration produces varying outputs across runs. The output-to-declaration mapping is neither injective nor deterministic.

Audit Trails

Audit trails record actions taken by actors within a system for compliance purposes. They reference executions using whatever identifiers are available. Without declarations, audit trails reference execution using incomplete, non-deterministic identifiers. The audit trail’s quality is bounded by the identity system it depends on. Audit trails document events; declarations specify executions. These are complementary but not interchangeable.

Category Boundary

An AI run declaration is a specific concept. It is necessary to distinguish it from related but distinct ideas:

• A declaration is NOT a prompt. A prompt is one component of a declaration. The declaration includes the model, parameters, context, and constraints in addition to the prompt.
• A declaration is NOT a request payload. An API request payload is a transport format. A declaration is a logical specification. The same declaration is expressed in different payload formats.
• A declaration is NOT a configuration snapshot. Configuration snapshots capture system state at a point in time. A declaration specifies execution parameters for a single run, independent of system state.
• A declaration is NOT an execution plan. An execution plan describes how a system will process a request. A declaration describes what the execution consists of, not how it is processed.
• A declaration is NOT a reproducibility recipe. Reproducibility recipes are instructions for recreating results. A declaration is the formal input to the identity function. Identity and reproducibility are related but serve different purposes.

For the broader treatment of identity boundaries, see What AI Identity Is Not.

Logical Inevitability

The declaration is the mechanism that makes this inevitability concrete. A stable, independently verifiable identity requires a fixed input. That fixed input must capture the complete execution specification. That complete specification is the declaration. Without a declaration, there is no fixed input. Without a fixed input, there is no deterministic identity. Without deterministic identity, verification and agreement are impossible.

Every alternative to formal declaration attempts to reconstruct execution parameters from downstream artifacts. Every reconstruction introduces error, incompleteness, and system dependency. The Verification Failure in AI is, at its root, a declaration failure. Systems that never declare their executions produce runs that no party independently verifies.

Implications

Formal AI run declarations transform the relationship between execution and identity:

• Execution becomes specified. Every AI Run Identity traces back to a complete, formal specification. The run is no longer a transient event. It is a declared, identifiable execution with a permanent reference.
• Identity becomes computable. With a formal declaration as input, any party computes the deterministic identity independently. No coordination, no central authority, and no shared infrastructure is required. The declaration is sufficient.
• Ambiguity becomes resolvable. Disputes about what an AI run consisted of are resolved by examining the declaration. The declaration is the authoritative source. It does not degrade, drift, or depend on any observer’s perspective.
• Completeness becomes verifiable. A formal declaration defines what must be specified. Missing parameters are detectable. Implicit parameters must be made explicit. The declaration enforces completeness because incomplete declarations produce incomplete identities, and incomplete identities are not valid within the protocol.

Frequently Asked Questions