EC
← All Starter Kits
Intermediate1 hourMCP (Model Context Protocol) · Python / TypeScript

MCP Agent Starter

1What This Kit Builds

A model-agnostic agent using the Model Context Protocol with ECZ-ID trust anchors. This kit produces an agent that connects to any MCP-compatible model while maintaining verified identity chains, enabling trusted multi-model orchestration with resolver-verifiable provenance.

2Who It Is For

Developers building model-agnostic AI agents that need to work across multiple LLM providers. Ideal for teams that want to avoid model vendor lock-in while maintaining verified identity and trust infrastructure across model switches.

3Why ECZ-ID Matters Here

When agents can switch between models, identity becomes even more critical. ECZ-ID ensures the agent’s verified identity persists regardless of which model is executing, making multi-model agents commercially legible and consistently verifiable through Resolver.

4Architecture

MCP Protocol Layer

Standard Model Context Protocol integration supporting any MCP-compatible model provider.

Model Router

Routes requests to appropriate models based on capability, cost, and availability while maintaining identity context.

ECZ-ID Trust Anchor

Persistent identity layer that remains constant regardless of which underlying model is active.

Context Window Manager

Manages identity context injection across model context windows, ensuring trust metadata persists.

Trust Metadata Passthrough

Ensures ECZ-ID trust metadata flows through MCP protocol boundaries without loss.

Multi-Model Audit Bridge

Unified audit logging across model switches, maintaining provenance continuity.

5Build Steps Overview

1
Clone the MCP agent starter
Pull the template with MCP protocol integration scaffolding.
2
Install dependencies
Install MCP client libraries, ECZ-ID SDK, and model provider adapters.
3
Configure MCP endpoints
Set up connections to your MCP-compatible model providers.
4
Define model routing rules
Specify how requests are routed across models and fallback logic.
5
Review trust anchor patterns
Understand how identity persists across model boundaries before credentialing.

Trust Map

Required Passports
ECZ-ID Business PassportAgent Credential
Recommended Passports
API PassportAI Model Passport
Relevant Packages
Agent Starter Package
What Each Enables
ECZ-ID Business Passport: Organisation-level identity anchor for model-agnostic agents
Agent Credential: Persistent verified identity across model switches
API Passport: Verified handoffs between MCP-compatible model endpoints
AI Model Passport: Provenance verification for each underlying model

6TrustOps Credentialing Checkpoint

TrustOps Credentialing Checkpoint

Pause here to acquire your required ECZ-ID trust objects

This is a designed pause point in your build process. Before continuing, you need to acquire the required ECZ-ID passports and credentials from TrustOps. This midpoint credentialing approach ensures your agent is built with verified identity from the start—not bolted on after the fact.

Required Passports

  • ECZ-ID Business Passport
  • Agent Credential

Recommended Passports

  • API Passport
  • AI Model Passport

Relevant Packages

Agent Starter Package

What You Must Acquire in TrustOps

ECZ-ID Business Passport
Enables: Parent organisation identity anchoring agent credentials
Agent Credential
Enables: Unique verified identity that persists across model switches
API Passport (recommended)
Enables: Verified API handoffs across MCP-compatible model providers
AI Model Passport (recommended)
Enables: Verification of each underlying model’s provenance

What You Bring Back from TrustOps

Agent ECZ-ID
Your agent’s unique, model-agnostic verified identity
Agent Credential Manifest
Capability attestations and model-independent operational boundaries
API Keys
Production ECZ-ID API keys for trust anchor management
Model Trust Configuration
Trust metadata templates for each connected model provider
Continue in TrustOpsView Required ECZ-ID Package

9Return and Complete Integration

With your TrustOps credentials in hand, return here to complete the final build steps.

1
Inject agent credentials
Add your Agent ECZ-ID and API keys to the MCP agent configuration.
2
Configure trust anchors
Wire ECZ-ID trust anchors into the MCP protocol layer.
3
Test model switching
Verify identity persistence when switching between model providers.
4
Validate passthrough
Confirm trust metadata passes correctly through MCP boundaries.
5
Enable unified audit
Activate cross-model audit logging with identity anchoring.

10Verify Through Resolver

Verify agent identity

Query your agent’s ECZ-ID through Resolver regardless of which model is active.

Verify cross-model provenance

Trace an output back through model switches to confirm continuous identity chain.

Check model attestations

If using AI Model Passports, verify the provenance of each connected model.

Validate trust continuity

Confirm trust scores remain consistent across model transitions.

Verify with Resolver

11Deploy Anywhere

ECZ-ID-backed agents are portable. Your verified identity travels with your agent regardless of deployment target. No vendor lock-in.

Any cloud provider (AWS, GCP, Azure)
Self-hosted infrastructure
Kubernetes clusters
Docker containers
Edge compute (with MCP support)
Hybrid multi-cloud

12Limits & Non-Claims

  • This kit does not provision ECZ-ID credentials. All credentialing happens through TrustOps.
  • This kit does not provide MCP model access. Model provider relationships are separate.
  • Identity verification is model-agnostic but requires real ECZ-ID credentials.
  • MCP protocol compatibility depends on model provider support.
  • Trust scores reflect agent behaviour, not underlying model quality.

Ready to Build This Agent?

Start with the build steps above, credential through TrustOps, and deploy your resolver-verifiable agent anywhere.

Continue in TrustOpsView All Starter Kits