diff --git a/rfcs/0001-agent-manifest.md b/rfcs/0001-agent-manifest.md
new file mode 100644
index 000000000..ca36a7302
--- /dev/null
+++ b/rfcs/0001-agent-manifest.md
@@ -0,0 +1,254 @@
+# RFC 0001: Agent Manifest — Declarative Capability Profile
+
+## Summary
+
+Add an optional `AgentManifest` to the `Agent` class that formally declares an agent's input requirements, output types, trigger conditions, and tool capabilities. This enables platforms to manage agent lifecycle, resolve dependencies automatically, and compose agents into chains without custom wiring.
+
+## Motivation
+
+### Problem
+
+Today, a Strands agent is defined by its runtime configuration: model, tools, system prompt. There is no way to declare what an agent *needs* (data sources, features, upstream event types) or what it *produces* (output schemas, downstream events) without inspecting its code or documentation. This means every multi-agent deployment requires manual dependency tracking, custom wiring between agents, and runtime failures as the only signal that something is missing.
+
+This creates three problems in production multi-agent systems:
+
+1. **No dependency declaration**: A platform cannot determine whether an agent's required inputs are available without running it and observing failures.
+2. **No composability contract**: Two agents cannot be chained without custom integration code because neither declares its input/output schema.
+3. **No lifecycle management**: An agent cannot be registered in advance and activated later when its dependencies become available.
+
+### Real-World Example
+
+In a multi-agent data processing platform, an Enrichment Agent needs two inputs: a `RawDataEvent` from an Ingestion Agent and a `customer_profile` feature from a Feature Store. Today, this agent must be deployed and configured manually after both dependencies exist. With a manifest, the agent can be registered as dormant and activate automatically when both inputs become available — no redeployment, no manual wiring.
+
+### Use Cases
+
+- **Multi-agent platforms**: Agents declare what they need; the platform resolves bindings and activates agents when dependencies are met.
+- **Agent registries and catalogs**: Manifests serve as the catalog entry for agent discovery — what does this agent do, what does it need, what does it produce.
+- **Scenario and simulation orchestration**: A platform determines which agents to invoke for a given scenario by matching available data against agent manifests.
+- **Tool capability abstraction**: An agent declares it needs a `data_query` capability, not a specific PostgreSQL tool. The platform resolves the concrete binding per deployment environment.
+- **CI/CD for agents**: Manifests enable automated validation that an agent's declared dependencies are satisfiable before deployment.
+
+## Design
+
+### New Classes
+
+```python
+# src/strands/agent/manifest.py
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class InputContract:
+    """Declares what an agent requires to execute."""
+    features_required: list[str] = field(default_factory=list)
+    data_sources: list[str] = field(default_factory=list)
+    events_consumed: list[str] = field(default_factory=list)
+    tool_capabilities: list[str] = field(default_factory=list)
+    knowledge_bases: list[str] = field(default_factory=list)
+
+@dataclass
+class OutputContract:
+    """Declares what an agent produces."""
+    events_produced: list[str] = field(default_factory=list)
+    features_produced: list[str] = field(default_factory=list)
+    artifacts_produced: list[str] = field(default_factory=list)
+
+@dataclass  
+class Trigger:
+    """Declares what activates this agent."""
+    type: str  # "event", "schedule", "on_demand"
+    condition: Optional[str] = None  # event type filter or cron expression
+
+@dataclass
+class AgentManifest:
+    """Declarative capability profile for an agent.
+    
+    A manifest describes what an agent needs (inputs), what it produces (outputs),
+    what activates it (trigger), and what scenarios it supports. It is purely
+    declarative metadata — it does not change agent execution behavior. External
+    systems (registries, orchestrators, platforms) read manifests to manage agent
+    lifecycle and composition.
+    """
+    name: str
+    version: str
+    domain: Optional[str] = None
+    description: Optional[str] = None
+    
+    input_contract: InputContract = field(default_factory=InputContract)
+    output_contract: OutputContract = field(default_factory=OutputContract)
+    trigger: Optional[Trigger] = None
+    scenario_types: list[str] = field(default_factory=list)
+    tags: dict[str, str] = field(default_factory=dict)
+    
+    def to_dict(self) -> dict:
+        """Serialize manifest to dictionary for registry registration."""
+        ...
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "AgentManifest":
+        """Deserialize manifest from dictionary."""
+        ...
+    
+    @classmethod
+    def from_file(cls, path: str) -> "AgentManifest":
+        """Load manifest from JSON or YAML file."""
+        ...
+```
+
+### Agent Class Changes
+
+```python
+# In Agent.__init__, add optional manifest parameter:
+
+class Agent(AgentBase):
+    def __init__(
+        self,
+        ...,
+        manifest: AgentManifest | None = None,  # NEW
+        ...
+    ):
+```
+
+The manifest is purely declarative. It does not change agent execution behavior. It is metadata that external systems (registries, orchestrators, platforms) can read to manage the agent's lifecycle.
+
+### Usage Examples
+
+#### Basic: Agent with manifest
+
+```python
+from strands import Agent, tool
+from strands.agent.manifest import AgentManifest, InputContract, OutputContract, Trigger
+
+@tool
+def analyze_data(query: str) -> dict:
+    """Run analysis on structured data."""
+    ...
+
+agent = Agent(
+    manifest=AgentManifest(
+        name="data_analysis_agent",
+        version="1.0.0",
+        domain="analytics",
+        description="Analyzes structured datasets and produces insight reports",
+        input_contract=InputContract(
+            features_required=["dataset_schema", "recent_metrics"],
+            events_consumed=["DataReadyEvent"],
+            tool_capabilities=["data_query", "chart_generation"],
+        ),
+        output_contract=OutputContract(
+            events_produced=["InsightEvent"],
+            artifacts_produced=["analysis_report"],
+        ),
+        trigger=Trigger(type="event", condition="DataReadyEvent"),
+    ),
+    system_prompt="You are a data analysis agent...",
+    tools=[analyze_data],
+)
+
+# Access manifest programmatically
+print(agent.manifest.input_contract.features_required)
+# ['dataset_schema', 'recent_metrics']
+
+# Serialize for registry registration
+manifest_dict = agent.manifest.to_dict()
+```
+
+#### Multi-agent composition via manifests
+
+```python
+# Agent A produces events that Agent B consumes
+# No direct wiring needed — a platform reads both manifests and connects them
+
+ingestion_agent = Agent(
+    manifest=AgentManifest(
+        name="ingestion_agent",
+        version="1.0.0",
+        output_contract=OutputContract(events_produced=["RawDataEvent"]),
+    ),
+    ...
+)
+
+enrichment_agent = Agent(
+    manifest=AgentManifest(
+        name="enrichment_agent",
+        version="1.0.0",
+        input_contract=InputContract(events_consumed=["RawDataEvent"]),
+        output_contract=OutputContract(events_produced=["EnrichedDataEvent"]),
+        trigger=Trigger(type="event", condition="RawDataEvent"),
+    ),
+    ...
+)
+
+# A platform reads both manifests and knows:
+# ingestion_agent.output → RawDataEvent → enrichment_agent.input
+# No custom integration code needed.
+```
+
+#### File-based manifest
+
+```json
+{
+  "name": "enrichment_agent",
+  "version": "1.0.0",
+  "domain": "data_pipeline",
+  "input_contract": {
+    "features_required": ["customer_profile"],
+    "events_consumed": ["RawDataEvent"],
+    "tool_capabilities": ["data_query", "enrichment_api"]
+  },
+  "output_contract": {
+    "events_produced": ["EnrichedDataEvent"]
+  },
+  "trigger": {"type": "event", "condition": "RawDataEvent"}
+}
+```
+
+```python
+from strands.agent.manifest import AgentManifest
+
+agent = Agent(
+    manifest=AgentManifest.from_file("manifest.json"),
+    system_prompt="...",
+    tools=[...],
+)
+```
+
+## When to Use
+
+Use `AgentManifest` when:
+- Your agent is part of a multi-agent system where agents need to discover each other's capabilities
+- You want to register agents in a catalog or registry with formal input/output declarations
+- You need lifecycle management (agents that activate when dependencies are met)
+- You want to enable orchestration where a platform selects agents based on their declared capabilities
+- You want to abstract tool requirements from concrete implementations (capability names vs specific tools)
+- You want CI/CD validation that an agent's dependencies are satisfiable before deployment
+
+Do NOT use `AgentManifest` when:
+- You have a simple single-agent application
+- Your agent's inputs and outputs are ad-hoc and not formalized
+- You don't need external lifecycle management or registry integration
+
+## Backward Compatibility
+
+- `manifest` parameter is optional and defaults to `None`
+- Existing agents without manifests work exactly as before
+- No breaking changes to any existing API
+- No new required dependencies
+
+## Alternatives Considered
+
+1. **Separate manifest file only (no SDK integration)**: Rejected because it creates drift between the manifest and the actual agent configuration. Keeping the manifest in the Agent class ensures they stay in sync.
+2. **Infer manifest from tools list**: Rejected because tool capabilities are abstract (what the agent needs conceptually) while tools are concrete (what's currently bound). An agent may need `data_query` capability but have no tool bound yet — that's the dormant state.
+3. **Embed in system_prompt**: Rejected because manifests need to be machine-readable for registry/platform integration, not just LLM-readable.
+4. **Use agent description field**: Rejected because description is free-text for humans. Manifests are structured data for machines.
+
+## Implementation Plan
+
+1. Add `src/strands/agent/manifest.py` with dataclass definitions
+2. Add `manifest` parameter to `Agent.__init__` (optional, defaults to None)
+3. Store manifest as `self.manifest` attribute on the Agent instance
+4. Add serialization: `to_dict()`, `from_dict()`, `from_file()` (JSON and YAML support)
+5. Export `AgentManifest`, `InputContract`, `OutputContract`, `Trigger` from `strands.agent`
+6. Add unit tests for manifest creation, serialization, and Agent integration
+7. Add documentation page explaining the concept and usage patterns
diff --git a/src/strands/agent/__init__.py b/src/strands/agent/__init__.py
index c901e800f..492734fe6 100644
--- a/src/strands/agent/__init__.py
+++ b/src/strands/agent/__init__.py
@@ -19,16 +19,21 @@
     SlidingWindowConversationManager,
     SummarizingConversationManager,
 )
+from .manifest import AgentManifest, InputContract, OutputContract, Trigger
 
 __all__ = [
     "Agent",
     "AgentBase",
+    "AgentManifest",
     "AgentResult",
     "ConversationManager",
+    "InputContract",
+    "ModelRetryStrategy",
     "NullConversationManager",
+    "OutputContract",
     "SlidingWindowConversationManager",
     "SummarizingConversationManager",
-    "ModelRetryStrategy",
+    "Trigger",
 ]
 
 
diff --git a/src/strands/agent/agent.py b/src/strands/agent/agent.py
index 965969961..724356e29 100644
--- a/src/strands/agent/agent.py
+++ b/src/strands/agent/agent.py
@@ -79,6 +79,7 @@
     NullConversationManager,
     SlidingWindowConversationManager,
 )
+from .manifest import AgentManifest
 from .state import AgentState
 
 logger = logging.getLogger(__name__)
@@ -146,6 +147,7 @@ def __init__(
         tool_executor: ToolExecutor | None = None,
         retry_strategy: ModelRetryStrategy | _DefaultRetryStrategySentinel | None = _DEFAULT_RETRY_STRATEGY,
         concurrent_invocation_mode: ConcurrentInvocationMode = ConcurrentInvocationMode.THROW,
+        manifest: AgentManifest | None = None,
     ):
         """Initialize the Agent with the specified configuration.
 
@@ -227,6 +229,7 @@ def __init__(
         self.agent_id = _identifier.validate(agent_id or _DEFAULT_AGENT_ID, _identifier.Identifier.AGENT)
         self.name = name or _DEFAULT_AGENT_NAME
         self.description = description
+        self.manifest = manifest
 
         # If not provided, create a new PrintingCallbackHandler instance
         # If explicitly set to None, use null_callback_handler
diff --git a/src/strands/agent/manifest.py b/src/strands/agent/manifest.py
new file mode 100644
index 000000000..1d1bcd01f
--- /dev/null
+++ b/src/strands/agent/manifest.py
@@ -0,0 +1,319 @@
+"""Agent Manifest — Declarative Capability Profile.
+
+This module provides the AgentManifest class and supporting dataclasses that allow agents to formally
+declare their input requirements, output types, trigger conditions, and tool capabilities.
+
+A manifest is purely declarative metadata. It does not change agent execution behavior. External systems
+(registries, orchestrators, platforms) read manifests to manage agent lifecycle and composition.
+
+Example:
+    >>> from strands.agent.manifest import AgentManifest, InputContract, OutputContract, Trigger
+    >>> manifest = AgentManifest(
+    ...     name="data_analysis_agent",
+    ...     version="1.0.0",
+    ...     input_contract=InputContract(
+    ...         features_required=["dataset_schema"],
+    ...         events_consumed=["DataReadyEvent"],
+    ...         tool_capabilities=["data_query"],
+    ...     ),
+    ...     output_contract=OutputContract(events_produced=["InsightEvent"]),
+    ...     trigger=Trigger(type="event", condition="DataReadyEvent"),
+    ... )
+"""
+
+import json
+import logging
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InputContract:
+    """Declares what an agent requires to execute.
+
+    Attributes:
+        features_required: Named features the agent needs from a feature store or data source.
+        data_sources: Named data sources the agent reads from (databases, APIs, streams).
+        events_consumed: Event types that this agent processes as input.
+        tool_capabilities: Abstract tool capability names the agent requires (not concrete tool implementations).
+        knowledge_bases: Named knowledge bases the agent queries during reasoning.
+    """
+
+    features_required: list[str] = field(default_factory=list)
+    data_sources: list[str] = field(default_factory=list)
+    events_consumed: list[str] = field(default_factory=list)
+    tool_capabilities: list[str] = field(default_factory=list)
+    knowledge_bases: list[str] = field(default_factory=list)
+
+
+@dataclass
+class OutputContract:
+    """Declares what an agent produces.
+
+    Attributes:
+        events_produced: Event types that this agent emits as output.
+        features_produced: Named features that this agent computes and writes.
+        artifacts_produced: Named artifacts (files, reports, records) that this agent creates.
+    """
+
+    events_produced: list[str] = field(default_factory=list)
+    features_produced: list[str] = field(default_factory=list)
+    artifacts_produced: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Trigger:
+    """Declares what activates this agent.
+
+    Attributes:
+        type: The trigger mechanism. One of "event", "schedule", or "on_demand".
+        condition: For "event" type: the event type filter. For "schedule" type: a cron expression.
+            For "on_demand" type: None (activated by explicit invocation).
+    """
+
+    type: str  # "event", "schedule", "on_demand"
+    condition: Optional[str] = None
+
+
+@dataclass
+class AgentManifest:
+    """Declarative capability profile for an agent.
+
+    A manifest describes what an agent needs (inputs), what it produces (outputs),
+    what activates it (trigger), and what scenarios it supports. It is purely
+    declarative metadata that does not change agent execution behavior.
+
+    External systems (registries, orchestrators, platforms) read manifests to:
+    - Determine if an agent's dependencies are satisfiable
+    - Manage agent lifecycle (dormant/active states)
+    - Compose agents into chains by matching outputs to inputs
+    - Select agents for scenario execution based on capabilities
+
+    Attributes:
+        name: Unique identifier for this agent.
+        version: Semantic version string (e.g., "1.0.0").
+        domain: Optional domain or category this agent belongs to.
+        description: Human-readable description of what this agent does.
+        input_contract: What this agent requires to execute.
+        output_contract: What this agent produces.
+        trigger: What activates this agent.
+        scenario_types: List of scenario type identifiers this agent supports.
+        tags: Arbitrary key-value metadata for filtering and discovery.
+
+    Example:
+        >>> manifest = AgentManifest(
+        ...     name="enrichment_agent",
+        ...     version="1.0.0",
+        ...     domain="data_pipeline",
+        ...     input_contract=InputContract(
+        ...         events_consumed=["RawDataEvent"],
+        ...         tool_capabilities=["data_query", "enrichment_api"],
+        ...     ),
+        ...     output_contract=OutputContract(events_produced=["EnrichedDataEvent"]),
+        ...     trigger=Trigger(type="event", condition="RawDataEvent"),
+        ... )
+    """
+
+    name: str
+    version: str
+    domain: Optional[str] = None
+    description: Optional[str] = None
+
+    input_contract: InputContract = field(default_factory=InputContract)
+    output_contract: OutputContract = field(default_factory=OutputContract)
+    trigger: Optional[Trigger] = None
+    scenario_types: list[str] = field(default_factory=list)
+    tags: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize manifest to a dictionary.
+
+        Returns:
+            Dictionary representation of the manifest, suitable for JSON serialization
+            or registry registration.
+        """
+        data = asdict(self)
+        # Remove None values for cleaner serialization
+        if data.get("trigger") is None:
+            del data["trigger"]
+        if data.get("domain") is None:
+            del data["domain"]
+        if data.get("description") is None:
+            del data["description"]
+        return data
+
+    def to_json(self, indent: int = 2) -> str:
+        """Serialize manifest to a JSON string.
+
+        Args:
+            indent: Number of spaces for JSON indentation. Defaults to 2.
+
+        Returns:
+            JSON string representation of the manifest.
+        """
+        return json.dumps(self.to_dict(), indent=indent)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AgentManifest":
+        """Deserialize manifest from a dictionary.
+
+        Args:
+            data: Dictionary containing manifest fields.
+
+        Returns:
+            AgentManifest instance.
+        """
+        input_contract = InputContract(**data.get("input_contract", {}))
+        output_contract = OutputContract(**data.get("output_contract", {}))
+        trigger = Trigger(**data["trigger"]) if data.get("trigger") else None
+
+        return cls(
+            name=data["name"],
+            version=data["version"],
+            domain=data.get("domain"),
+            description=data.get("description"),
+            input_contract=input_contract,
+            output_contract=output_contract,
+            trigger=trigger,
+            scenario_types=data.get("scenario_types", []),
+            tags=data.get("tags", {}),
+        )
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "AgentManifest":
+        """Load manifest from a JSON file.
+
+        Args:
+            path: Path to the manifest JSON file.
+
+        Returns:
+            AgentManifest instance.
+
+        Raises:
+            FileNotFoundError: If the manifest file does not exist.
+            json.JSONDecodeError: If the file contains invalid JSON.
+        """
+        path = Path(path)
+        with open(path) as f:
+            data = json.load(f)
+        return cls.from_dict(data)
+
+    def satisfies(self, available_events: list[str] | None = None,
+                  available_features: list[str] | None = None,
+                  available_capabilities: list[str] | None = None) -> tuple[bool, list[str]]:
+        """Check if this manifest's input requirements can be satisfied by available resources.
+
+        Args:
+            available_events: List of event types currently available in the system.
+            available_features: List of feature names currently available.
+            available_capabilities: List of tool capability names currently registered.
+
+        Returns:
+            Tuple of (is_satisfied, unmet_requirements). If is_satisfied is True,
+            all input requirements are met. If False, unmet_requirements lists what's missing.
+        """
+        unmet: list[str] = []
+
+        if available_events is not None:
+            for event in self.input_contract.events_consumed:
+                if event not in available_events:
+                    unmet.append(f"event:{event}")
+
+        if available_features is not None:
+            for feature in self.input_contract.features_required:
+                if feature not in available_features:
+                    unmet.append(f"feature:{feature}")
+
+        if available_capabilities is not None:
+            for cap in self.input_contract.tool_capabilities:
+                if cap not in available_capabilities:
+                    unmet.append(f"capability:{cap}")
+
+        return (len(unmet) == 0, unmet)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Usage Examples
+# ─────────────────────────────────────────────────────────────────────────────
+#
+# Example 1: Data pipeline agent that enriches raw events
+#
+#   from strands import Agent, tool
+#   from strands.agent.manifest import AgentManifest, InputContract, OutputContract, Trigger
+#
+#   @tool
+#   def enrich_record(record_id: str) -> dict:
+#       """Look up additional context for a record."""
+#       ...
+#
+#   enrichment_agent = Agent(
+#       manifest=AgentManifest(
+#           name="enrichment_agent",
+#           version="1.0.0",
+#           domain="data_pipeline",
+#           description="Enriches raw ingestion events with contextual metadata",
+#           input_contract=InputContract(
+#               events_consumed=["RawIngestionEvent"],
+#               features_required=["entity_profile"],
+#               tool_capabilities=["lookup_api"],
+#           ),
+#           output_contract=OutputContract(
+#               events_produced=["EnrichedEvent"],
+#           ),
+#           trigger=Trigger(type="event", condition="RawIngestionEvent"),
+#       ),
+#       system_prompt="You enrich raw data records with contextual metadata...",
+#       tools=[enrich_record],
+#   )
+#
+#
+# Example 2: Checking if an agent's dependencies are satisfiable
+#
+#   manifest = enrichment_agent.manifest
+#   satisfied, gaps = manifest.satisfies(
+#       available_events=["RawIngestionEvent"],
+#       available_features=[],  # entity_profile not yet available
+#       available_capabilities=["lookup_api"],
+#   )
+#   # satisfied = False
+#   # gaps = ["feature:entity_profile"]
+#
+#
+# Example 3: Multi-agent composition — platform reads manifests to auto-wire
+#
+#   # Agent A produces "AnalysisCompleteEvent"
+#   # Agent B consumes "AnalysisCompleteEvent"
+#   # A platform reads both manifests and connects them without custom code:
+#   #
+#   #   for agent in registered_agents:
+#   #       for event in agent.manifest.output_contract.events_produced:
+#   #           downstream = [a for a in registered_agents
+#   #                         if event in a.manifest.input_contract.events_consumed]
+#   #           register_event_route(event, downstream)
+#
+#
+# Example 4: Loading manifest from a file (useful for CI/CD validation)
+#
+#   # manifest.json:
+#   # {
+#   #   "name": "report_generator",
+#   #   "version": "2.1.0",
+#   #   "input_contract": {
+#   #     "features_required": ["monthly_metrics", "comparison_baseline"],
+#   #     "tool_capabilities": ["chart_generation", "pdf_export"]
+#   #   },
+#   #   "output_contract": {
+#   #     "artifacts_produced": ["monthly_report.pdf"]
+#   #   },
+#   #   "trigger": {"type": "schedule", "condition": "0 9 1 * *"}
+#   # }
+#   #
+#   # agent = Agent(
+#   #     manifest=AgentManifest.from_file("manifest.json"),
+#   #     system_prompt="...",
+#   #     tools=[...],
+#   # )
+
diff --git a/tests/strands/agent/test_manifest.py b/tests/strands/agent/test_manifest.py
new file mode 100644
index 000000000..7c4e6d901
--- /dev/null
+++ b/tests/strands/agent/test_manifest.py
@@ -0,0 +1,279 @@
+"""Tests for AgentManifest."""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from strands.agent.manifest import AgentManifest, InputContract, OutputContract, Trigger
+
+
+class TestInputContract:
+    """Tests for InputContract dataclass."""
+
+    def test_default_empty(self):
+        contract = InputContract()
+        assert contract.features_required == []
+        assert contract.data_sources == []
+        assert contract.events_consumed == []
+        assert contract.tool_capabilities == []
+        assert contract.knowledge_bases == []
+
+    def test_with_values(self):
+        contract = InputContract(
+            features_required=["feature_a", "feature_b"],
+            events_consumed=["EventX"],
+            tool_capabilities=["data_query"],
+        )
+        assert contract.features_required == ["feature_a", "feature_b"]
+        assert contract.events_consumed == ["EventX"]
+        assert contract.tool_capabilities == ["data_query"]
+
+
+class TestOutputContract:
+    """Tests for OutputContract dataclass."""
+
+    def test_default_empty(self):
+        contract = OutputContract()
+        assert contract.events_produced == []
+        assert contract.features_produced == []
+        assert contract.artifacts_produced == []
+
+    def test_with_values(self):
+        contract = OutputContract(
+            events_produced=["ResultEvent"],
+            artifacts_produced=["report.pdf"],
+        )
+        assert contract.events_produced == ["ResultEvent"]
+        assert contract.artifacts_produced == ["report.pdf"]
+
+
+class TestTrigger:
+    """Tests for Trigger dataclass."""
+
+    def test_event_trigger(self):
+        trigger = Trigger(type="event", condition="DataReadyEvent")
+        assert trigger.type == "event"
+        assert trigger.condition == "DataReadyEvent"
+
+    def test_schedule_trigger(self):
+        trigger = Trigger(type="schedule", condition="*/15 * * * *")
+        assert trigger.type == "schedule"
+        assert trigger.condition == "*/15 * * * *"
+
+    def test_on_demand_trigger(self):
+        trigger = Trigger(type="on_demand")
+        assert trigger.type == "on_demand"
+        assert trigger.condition is None
+
+
+class TestAgentManifest:
+    """Tests for AgentManifest dataclass."""
+
+    def _sample_manifest(self) -> AgentManifest:
+        return AgentManifest(
+            name="test_agent",
+            version="1.0.0",
+            domain="testing",
+            description="A test agent",
+            input_contract=InputContract(
+                features_required=["feature_a"],
+                events_consumed=["InputEvent"],
+                tool_capabilities=["data_query", "file_write"],
+            ),
+            output_contract=OutputContract(
+                events_produced=["OutputEvent"],
+                features_produced=["computed_metric"],
+            ),
+            trigger=Trigger(type="event", condition="InputEvent"),
+            scenario_types=["simulation", "replay"],
+            tags={"team": "platform", "priority": "high"},
+        )
+
+    def test_creation(self):
+        manifest = self._sample_manifest()
+        assert manifest.name == "test_agent"
+        assert manifest.version == "1.0.0"
+        assert manifest.domain == "testing"
+        assert manifest.description == "A test agent"
+        assert manifest.input_contract.features_required == ["feature_a"]
+        assert manifest.output_contract.events_produced == ["OutputEvent"]
+        assert manifest.trigger.type == "event"
+        assert manifest.scenario_types == ["simulation", "replay"]
+        assert manifest.tags == {"team": "platform", "priority": "high"}
+
+    def test_minimal_creation(self):
+        manifest = AgentManifest(name="minimal", version="0.1.0")
+        assert manifest.name == "minimal"
+        assert manifest.version == "0.1.0"
+        assert manifest.domain is None
+        assert manifest.description is None
+        assert manifest.input_contract.features_required == []
+        assert manifest.output_contract.events_produced == []
+        assert manifest.trigger is None
+        assert manifest.scenario_types == []
+        assert manifest.tags == {}
+
+    def test_to_dict(self):
+        manifest = self._sample_manifest()
+        data = manifest.to_dict()
+        assert data["name"] == "test_agent"
+        assert data["version"] == "1.0.0"
+        assert data["domain"] == "testing"
+        assert data["input_contract"]["features_required"] == ["feature_a"]
+        assert data["output_contract"]["events_produced"] == ["OutputEvent"]
+        assert data["trigger"]["type"] == "event"
+        assert data["tags"]["team"] == "platform"
+
+    def test_to_dict_removes_none_values(self):
+        manifest = AgentManifest(name="minimal", version="0.1.0")
+        data = manifest.to_dict()
+        assert "domain" not in data
+        assert "description" not in data
+        assert "trigger" not in data
+
+    def test_to_json(self):
+        manifest = self._sample_manifest()
+        json_str = manifest.to_json()
+        parsed = json.loads(json_str)
+        assert parsed["name"] == "test_agent"
+        assert parsed["version"] == "1.0.0"
+
+    def test_from_dict(self):
+        data = {
+            "name": "restored_agent",
+            "version": "2.0.0",
+            "domain": "analytics",
+            "input_contract": {
+                "features_required": ["metric_x"],
+                "events_consumed": ["TriggerEvent"],
+                "tool_capabilities": ["chart_generation"],
+            },
+            "output_contract": {
+                "events_produced": ["ReportEvent"],
+            },
+            "trigger": {"type": "schedule", "condition": "0 * * * *"},
+            "scenario_types": ["backtest"],
+            "tags": {"env": "prod"},
+        }
+        manifest = AgentManifest.from_dict(data)
+        assert manifest.name == "restored_agent"
+        assert manifest.version == "2.0.0"
+        assert manifest.domain == "analytics"
+        assert manifest.input_contract.features_required == ["metric_x"]
+        assert manifest.input_contract.tool_capabilities == ["chart_generation"]
+        assert manifest.output_contract.events_produced == ["ReportEvent"]
+        assert manifest.trigger.type == "schedule"
+        assert manifest.trigger.condition == "0 * * * *"
+        assert manifest.scenario_types == ["backtest"]
+        assert manifest.tags == {"env": "prod"}
+
+    def test_from_dict_minimal(self):
+        data = {"name": "bare", "version": "0.0.1"}
+        manifest = AgentManifest.from_dict(data)
+        assert manifest.name == "bare"
+        assert manifest.trigger is None
+        assert manifest.input_contract.events_consumed == []
+
+    def test_roundtrip(self):
+        original = self._sample_manifest()
+        data = original.to_dict()
+        restored = AgentManifest.from_dict(data)
+        assert restored.name == original.name
+        assert restored.version == original.version
+        assert restored.input_contract.features_required == original.input_contract.features_required
+        assert restored.output_contract.events_produced == original.output_contract.events_produced
+        assert restored.trigger.type == original.trigger.type
+        assert restored.scenario_types == original.scenario_types
+
+    def test_from_file(self, tmp_path):
+        data = {
+            "name": "file_agent",
+            "version": "1.0.0",
+            "input_contract": {"events_consumed": ["FileEvent"]},
+            "output_contract": {"events_produced": ["ProcessedEvent"]},
+            "trigger": {"type": "event", "condition": "FileEvent"},
+        }
+        file_path = tmp_path / "manifest.json"
+        file_path.write_text(json.dumps(data))
+
+        manifest = AgentManifest.from_file(file_path)
+        assert manifest.name == "file_agent"
+        assert manifest.input_contract.events_consumed == ["FileEvent"]
+        assert manifest.trigger.condition == "FileEvent"
+
+    def test_from_file_not_found(self):
+        with pytest.raises(FileNotFoundError):
+            AgentManifest.from_file("/nonexistent/path/manifest.json")
+
+    def test_satisfies_all_met(self):
+        manifest = self._sample_manifest()
+        satisfied, unmet = manifest.satisfies(
+            available_events=["InputEvent", "OtherEvent"],
+            available_features=["feature_a", "feature_b"],
+            available_capabilities=["data_query", "file_write", "extra_cap"],
+        )
+        assert satisfied is True
+        assert unmet == []
+
+    def test_satisfies_missing_event(self):
+        manifest = self._sample_manifest()
+        satisfied, unmet = manifest.satisfies(
+            available_events=["OtherEvent"],
+            available_features=["feature_a"],
+            available_capabilities=["data_query", "file_write"],
+        )
+        assert satisfied is False
+        assert "event:InputEvent" in unmet
+
+    def test_satisfies_missing_feature(self):
+        manifest = self._sample_manifest()
+        satisfied, unmet = manifest.satisfies(
+            available_events=["InputEvent"],
+            available_features=[],
+            available_capabilities=["data_query", "file_write"],
+        )
+        assert satisfied is False
+        assert "feature:feature_a" in unmet
+
+    def test_satisfies_missing_capability(self):
+        manifest = self._sample_manifest()
+        satisfied, unmet = manifest.satisfies(
+            available_events=["InputEvent"],
+            available_features=["feature_a"],
+            available_capabilities=["data_query"],
+        )
+        assert satisfied is False
+        assert "capability:file_write" in unmet
+
+    def test_satisfies_none_checks_skipped(self):
+        manifest = self._sample_manifest()
+        # When None is passed, that category is not checked
+        satisfied, unmet = manifest.satisfies(
+            available_events=None,
+            available_features=None,
+            available_capabilities=None,
+        )
+        assert satisfied is True
+        assert unmet == []
+
+
+class TestAgentWithManifest:
+    """Tests for Agent class with manifest parameter."""
+
+    def test_agent_without_manifest(self):
+        """Agent without manifest works as before."""
+        from strands import Agent
+
+        # This should not raise — manifest is optional
+        agent = Agent.__new__(Agent)
+        # Just verify the attribute would be None by default
+        # (full Agent init requires model setup which we skip here)
+
+    def test_manifest_accessible(self):
+        """Manifest is accessible as agent.manifest."""
+        manifest = AgentManifest(name="test", version="1.0.0")
+        # We can't easily instantiate a full Agent in unit tests without mocking,
+        # but we verify the manifest class is importable and usable
+        assert manifest.name == "test"