CapIX Protocol

Intelligent workload-routing that dynamically slashes AI costs and scales your token purchasing power.

Comment

Inspiration

AI infrastructure is becoming a market, but developers still buy it like old cloud: one oversized instance, one fixed hourly price, and a lot of wasted spend. Most workloads are mixed. A script might contain cheap sequential work like parsing, setup, logging, and data cleaning, alongside expensive parallel work like tensor operations, training loops, or matrix math.

CapIX was built around a simple idea: compute and inference should be traded, routed, and redeemed like liquid infrastructure assets. Buyers should be able to purchase capacity at market rates. Sellers should be able to list idle GPU, CPU, or model-serving capacity. Smart routing then makes the exchange more efficient by sending each part of the workload to the cheapest capable route.

What It Does

CapIX is an AI infrastructure exchange with intelligent routing.

  • Buy compute or inference capacity: Buyers compare live CPX-denominated routes and redeem capacity for SSH leases or streamed inference.
  • Sell capacity: Providers list available compute windows or model-serving routes against visible market demand.
  • Smart Route for compute: The CapIX router splits uploaded jobs into CPU and GPU segments, so simple sequential work does not run on premium GPU lanes.
  • Smart Route for inference: Complex prompts are decomposed into subtasks and routed across model providers by price, latency, reliability, and capability.
  • CPX settlement: A Phantom wallet deposit gates access to the private router, preventing abuse before CapIX reveals the optimized route.
  • Token utility: The exchange shows how CPX purchasing power maps to real compute pricing, making infrastructure capacity understandable as a tradeable asset.

How We Built It

CapIX combines a private exchange application with an open-source routing layer.

  • Frontend exchange: Built with Next.js, React, TypeScript, and Tailwind CSS. The UI includes Buy, Sell, Exchange, Compute, Inference, and Whitepaper flows.
  • Wallet and settlement layer: Uses Solana and Phantom wallet flows for CPX authorization, deposit proof, and demo settlement receipts.
  • Open-source router: The public Capix-MCP-Router repo contains the inspectable routing engine, FastMCP server, HTTP bridge, schemas, prompts, tests, and deployment scripts.
  • MongoDB MCP: MongoDB Atlas stores compute and inference route books. The router reads those routes through a hosted MongoDB MCP server, giving the agent live market context.
  • Gemini routing agent: Gemini evaluates uploaded workloads and returns strict JSON allocations across CPU/GPU lanes or inference provider routes.
  • Google Cloud: Cloud Run hosts the router and MongoDB MCP service. Cloud Build, Artifact Registry, Secret Manager, and Vertex AI/Gemini support the deployment path.
  • Controlled execution demo: For safety, the public router produces route plans and quotes. The private CapIX app owns paid access, wallet proof, and controlled delivery handoff.

Mathematical Model

For compute routing, CapIX compares the cost of running the full job on the highest required compute lane against the optimized routed plan.

Baseline Cost = Highest Required Route Rate x Full Job Runtime
Optimized Cost = sum(Route Rate_i x Segment Runtime_i)
Savings = 1 - (Optimized Cost / Baseline Cost)

For token purchasing power, the Exchange page maps real-world compute pricing into CPX terms.

CPX per hour = USD compute price per hour / CPX market value

Example:

H100 compute = $2.00/hr

If CPX = $0.01, compute costs 200 CPX/hr.
If CPX = $0.05, compute costs 40 CPX/hr.
If CPX = $0.10, compute costs 20 CPX/hr.

As CPX value increases, the token cost required to access the same infrastructure decreases.

Challenges We Ran Into

The hardest part was making AI routing deterministic enough for a live demo. Early Gemini outputs were sometimes too conversational or failed to preserve exact line ranges. We solved this with strict JSON prompts, schema validation, deterministic fallbacks, and route normalization from MongoDB.

Another challenge was product clarity. CapIX is not just a router; it is an exchange. We had to make the buyer path, seller path, price discovery, and smart routing feel like one coherent market rather than separate demos.

Accomplishments That We’re Proud Of

We built a working exchange experience for both compute and inference markets, with clear buyer and seller flows. We also connected MongoDB MCP to an AI routing agent so Gemini can reason over live route books instead of hardcoded demo nodes.

The strongest part is the end-to-end story: a seller lists capacity, a buyer pays CPX, CapIX unlocks Smart Route, MongoDB MCP provides market depth, Gemini produces the route plan, and the private app handles delivery.

What We Learned

We learned that MCP is powerful when it gives an agent real operational context. Instead of asking Gemini to guess, CapIX gives it a structured market: available routes, prices, reliability, latency, and hardware class.

We also learned that a strong hackathon MVP needs more than technical depth. The market primitives have to be obvious: supply, demand, price, settlement, and delivery.

What’s Next

Next, we want to move CapIX from a controlled MVP into a larger provider network.

Planned next steps:

  • Add more real provider integrations for compute and inference.
  • Expand seller onboarding with health checks and capacity verification.
  • Add stronger escrow and refund settlement flows.
  • Support batch jobs, eval workloads, and agent workflow routing.
  • Improve provider reputation scoring and route reliability metrics.
  • Turn CPX into the primary utility layer for redeemable AI infrastructure capacity.

CapIX’s long-term goal is to become the exchange where AI builders buy, sell, route, and redeem compute and inference capacity in real time.

Built With

Share this project:

Updates