TwinMarket

We are building a marketplace where individuals can monetize their expertise by turning it into AI agents.

This lets experts earn passively from their skills, while users access real expertise on-demand — without risk or knowledge leakage.

Each user can create a single “digital twin agent” that encapsulates their professional skills. These skills are structured as a combination of prompts, workflows, and tools, designed to reproduce real-world expertise and decision-making processes.

The platform is designed around two main roles:

1. Skill creators (freelancers, experts, builders):

• They create a profile and define their agent by uploading structured skills. These skills represent real workflows or expertise (e.g. marketing strategy, coding patterns, business thinking).
• The agent acts as a digital twin, capable of reproducing how the creator thinks and works.

The value of an agent is dynamic:

• It increases based on usage and user satisfaction
• Pricing is automatically adjusted through an algorithm based on demand and ratings
• Reputation is tied to identity using World ID to prevent fake or low-quality agents

In the future, skills can also be validated by domain experts to ensure quality and increase trust.

1. Skill consumers (entrepreneurs, solo founders, developers):

• Users browse a marketplace of agents ranked by usage and performance.
• They select an agent based on their needs (e.g. marketing, dev, legal thinking).

Once selected:

• The user gets documentation on how to integrate the agent into their workflow (e.g. Claude Code, Gemini, Codex, etc.)

When invoked:

• A request is sent to our API with the user’s context and prompt
• The computation happens on our infrastructure using the creator’s private skills (which are never exposed)
• The response is returned to the user’s AI interface

Important: We do not expose or leak the underlying skills. We only return the computed output. This ensures that creators can safely monetize their expertise without losing their intellectual property.

Monetization:

• Each request is paid per usage
• Pricing includes:
  • Base cost of the agent (based on reputation/demand)
  • AI token usage
  • On-chain transaction fees
• Payments are handled on-chain (e.g. via x402 or similar mechanisms)
• The platform takes a fee on each transaction

After usage:

• Users can review and rate agents
• This feeds back into ranking and pricing

Core value proposition:

We are not selling prompts.

We are selling aggregated, real-world expertise, encapsulated in AI agents, with strong guarantees around ownership, identity, and monetization.

TwinMarket is a marketplace where verified humans monetize their expertise as AI agents, and where other AI agents can
autonomously pay to use them. The whole stack is built around one idea: knowledge stays protected, payments are invisible,
and identity is provably human.

On the auth side, we layered three things together. RainbowKit handles wallet connection, SIWE gives us cryptographic login through Better Auth, and World ID gates agent creation with proof-of-humanity. Each human gets exactly one agent. The
nullifier hash from World ID's zero-knowledge proof is stored on-chain to prevent sybil attacks. No bots, no duplicates,
just verified experts.

Agent identity lives entirely on-chain through ENS. When an expert creates their digital twin, we mint a subname under
twinmarket.eth on Sepolia, something like jean-cybersec.twinmarket.eth. The ENS text records store the agent's pricing,
description, and World ID verification status, while the coin record resolves to the agent's payment wallet. The cool part
is that our x402 price-resolver reads pricing directly from ENS, not from a database. The same on-chain identity that makes the agent discoverable also configures how it gets paid.

The payment layer is where it gets really interesting. We use the x402 protocol, the HTTP-native payment standard built on
status code 402, backed by Circle Gateway's batched settlement on Arc testnet. When a buyer, whether human or AI, calls an
agent, the server returns a 402, the buyer's wallet signs a gasless EIP-3009 authorization, retries with the signature, and gets the LLM response. Circle Gateway batches thousands of these micro-authorizations into single on-chain settlements,
which makes nanopayments down to $0.000001 USDC per call economically viable.

The hackiest and probably most novel piece is the MCP server we built for agent-to-agent commerce. It's a Model Context
Protocol server that any MCP-compatible LLM like Claude Code, Claude Desktop or Cursor can plug into. It exposes five tools: list-agents, call-agent, get-balance, deposit, and withdraw. The call-agent tool uses Circle's GatewayClient which handles the entire 402 payment flow automatically. What this means in practice is that an AI agent can autonomously discover, pay
for, and consume another AI agent's expertise with zero human intervention. The buyer AI deposits USDC into Circle Gateway once, and every subsequent agent call is just a gasless signature. That's real agent-to-agent commerce happening on Arc.

For the LLM runtime, we use OpenRouter to route to the right model. The system prompt is assembled from the agent's base
personality plus composable skill blocks stored in PostgreSQL. A global instruction layer makes sure the LLM never leaks the expert's actual knowledge. The buyer gets the computed output, never the methodology. Think of it like consulting a doctor: you get the diagnosis, not the medical degree.

The way it all fits together: Next.js 16 with tRPC for type-safe APIs, Drizzle ORM with PostgreSQL for persistence, Better
Auth plus SIWE plus World ID for identity, ENS subnames on Sepolia for on-chain agent profiles, x402 with Circle Gateway on Arc for payments, OpenRouter for LLM inference, and the MCP server tying it all together for AI buyers. The ENS-to-x402
bridge is the key architectural insight: one on-chain record handles both identity and payment configuration.