Inspiration

The current landscape of e-commerce is highly manual and relies entirely on centralized trust. Setting up a storefront, curating products, verifying supplier authenticity, and managing payments require significant human operations.

We asked ourselves:
What if an entire e-commerce ecosystem could run autonomously while maintaining zero-trust cryptographic security?

We were inspired to build Credo, a truly AI-native commerce system where autonomous agents manage the entire retail lifecycle—from product curation to fulfillment—and where financial settlement is handled by machine-to-machine (M2M) smart contracts interacting directly with verifiable supplier credentials.

What It Does

Credo is a fully autonomous storefront and supply chain engine. It operates using four specialized AI agents:

🕵️ Scout Agent

Continuously scours the web for trending products
Evaluates them against margin and category thresholds

✍️ Merchandiser Agent

Takes profitable product leads
Generates high-converting marketing copy and titles
Publishes them to the storefront

📦 Logistics Agent

Handles fulfillment
Cryptographically verifies supplier identity using DIDKit
Releases funds only after verification

🎧 Support Agent

Interacts with customers
Checks order statuses
Uses vector search to answer policy-related queries autonomously

Under the Hood

Credo uses x402 for machine-to-machine payment rails, ensuring:

Payments are executed via decentralized escrow
Funds are released only after Verifiable Credentials (VCs) are proven

The Math Behind the Magic

To ensure the Scout Agent only curates profitable and viral products, we implemented a custom scoring algorithm.

For any discovered product $p$, the viability score $V(p)$ is calculated by evaluating its trend momentum against market saturation and retail margin:

$$ V(p) = \left(\alpha \cdot \frac{d(\text{Trend})}{dt}\right)

\left(\beta \cdot \frac{P_{\text{retail}} - P_{\text{wholesale}}}{P_{\text{retail}}}\right)
\left(\gamma \cdot \text{Saturation}_{\text{index}}\right) $$

Where:

$\alpha$ = weight for trend momentum
$\beta$ = weight for profit margin
$\gamma$ = weight for market saturation

If:

$$ V(p) > \tau $$

(where $\tau$ is a dynamic threshold), the Scout Agent passes the product up the pipeline to the Merchandiser for immediate publication.

How We Built It

Frontend

Next.js
TypeScript
Tailwind CSS
Real-time state management for cart and agent updates

Backend

FastAPI (Python 3.12)
Domain-isolated agent modules
LLMs with constrained reasoning scopes

Data Layer

Supabase (Postgres)
Vector extensions for semantic search
Realtime triggers for agent workflows

Trust & Payments

DIDKit for decentralized identity verification
Base-Sepolia network for execution
x402 framework for atomic escrow payments

Video Generation

Custom pipeline using Remotion (TypeScript)
Programmatic rendering of demo and pitch videos

Challenges We Ran Into

Agent Hallucinations vs. State Machines

Pure LLM-based logistics proved unreliable
Solution:
- Enforced strict JSON outputs via Pydantic
- Treated LLMs as decision engines within deterministic state machines

Bridging Web2 and Web3

Integrating DIDKit and x402 into a smooth UX was complex
Challenges included:
- Verifiable Presentation generation
- DIDComm timeout handling
Achieved seamless UX despite decentralized complexity

Accomplishments

🚀 End-to-End Autonomy

Fully autonomous pipeline:
1. Product discovery
2. Listing generation
3. Customer purchase
4. Supplier verification
5. M2M payment execution
First successful autonomous order via x402 was a major milestone

🎨 Production-Grade UX

Full-featured admin dashboard
Live agent logs
Identity Ledger visualization

🎬 Programmatic Pitch Video

Built entirely using React + Remotion
Fully automated motion graphics pipeline

What We Learned

Multi-agent systems require strict isolation and coordination
LLMs work best as bounded decision engines—not free-form operators
The future of AI commerce lies in:
- Specialized agents
- Autonomous coordination
- Crypto-native settlement systems