Struct Spec 

pub struct Spec {

    pub identity: Option<Identity>,
    pub security: Security,
    pub capabilities: Capabilities,
    pub budgets: Option<Budgets>,
    pub tools: Vec<ToolGrant>,
    pub context: ContextGrants,
    pub oversight: Option<Oversight>,
    pub execution: Option<Execution>,
    pub topology: Option<Topology>,
    pub models: Option<Models>,
    pub model: Option<ModelRef>,
    pub input: Option<Input>,
    pub output: Option<Output>,
    pub memory: Option<Memory>,
    pub data_subjects: Vec<DataSubject>,
}

The declaration proper.

Fields

identity: Option<Identity>

Who the agent is told it is.

Optional, because an embedder may compose its prompt in code. Supplying it here is what makes the prompt part of the manifest’s digest — see Identity.

security: Security

capabilities: Capabilities

budgets: Option<Budgets>

Absent means unbounded, and that is a decision the manifest has to state out loud — see Manifest::validate.

tools: Vec<ToolGrant>

Tools this agent may call. An empty list grants nothing.

context: ContextGrants

External context this agent may retrieve.

Separate from tools because reads of prompts/resources do not grant an action, but they still cross a trust and data-egress boundary and must not be invisible in a manifested agent’s review artifact.

oversight: Option<Oversight>

Whether a human decides before this agent’s answer is returned.

Only meaningful with execution: a hand-written skill chooses its own moment to ask, and a declaration this crate could not enforce would be exactly the decoration Manifest::validate refuses. So oversight without execution is rejected rather than ignored.

execution: Option<Execution>

How this agent runs — and whether it needs any code at all.

Declaring it makes the agent fully declarative: the runtime supplies the behaviour and the embedder writes no skill. Omitting it means the behaviour is a registered Skill, and this manifest governs its boundary rather than its conduct.

The difference is what the digest covers. A declarative agent is content-addressed in its entirety; a coded one is content-addressed only as far as its declaration reaches.

topology: Option<Topology>

What this agent is in a multi-agent arrangement.

Absent means Topology::default — a lone specialist, which is the only shape with no inter-agent failure surface.

models: Option<Models>

Which models this agent runs on.

Absent means wired in code. models: {} means no inference at all, declared on purpose — a rules-only agent is a legitimate design, and saying so out loud is what distinguishes it from one whose model wiring somebody forgot.

Unlike budgets, absence is not refused: an unstated budget is unbounded spend, whereas an unstated model is simply a wiring decision the embedder makes. The asymmetry is deliberate — refuse the silence that costs money, not the silence that costs nothing.

model: Option<ModelRef>

Shorthand for models: { privileged: … }, the single-model case.

Resolved into models before anything reads the document, so the digest is over the longhand: the two spellings of one declaration have one identity. Refused beside models, which would be two answers to one question.

input: Option<Input>

The shape of what this agent takes.

Optional, because a caller writing Rust against a skill it also wrote needs no declaration. See Input for the caller that does.

output: Option<Output>

The shape of what this agent returns.

Optional, because not every agent has a machine-readable result. See Output for why declaring it here rather than in code is the point.

memory: Option<Memory>

What this agent reads from and writes to durable memory.

data_subjects: Vec<DataSubject>

Whose data a run of this agent takes in, read from the run.

Each binding is resolved once per run into its DataSubjectBound record, and every value derived from the run’s input, events and case state is attributed to it, so a subject’s trace follows that data to the effects it reached. A binding that resolves to nothing refuses the run.

Trait Implementations

impl Clone for Spec

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Spec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Spec

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Spec

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Spec

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Spec

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Spec

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Spec