Sella

Agentic Marketplace enabling AI to autonomously access paywalled APIs,Datasets, GPU nodes, Cloud VMs and everything necessary

Comment

Inspiration

At Vibecon, Jared Friedman said something that stuck: he wants to see more products built for agents as users. That framing clicked immediately, because the gap is obvious once you see it. Every developer tool, every API marketplace, every data platform today is built for humans navigating dashboards and reading documentation. An AI agent has none of that luxury. It needs to discover resources, evaluate them, pay for them, and use them autonomously — and there is no infrastructure built to support that end-to-end.

I had been building on Stellar's x402 payment protocol during the Stellar Garage residency and could see exactly where this was going: agentic commerce. Not agents helping humans shop, but agents themselves as the economic actor. That became Sella.

What it does

Sella is an agentic marketplace that gives AI agents autonomous access to the resources they need to complete tasks: paywalled APIs, curated datasets, GPU nodes, cloud infrastructure, and more. An agent given a task can onboard to Sella through a single MCP-compatible skill file, get assigned wallets across Solana, Ethereum, Stellar, and Sui, and begin discovering and purchasing resources without any human intervention in the loop.

The platform has three core layers. The first is the resource catalogue, which is more agent-focused than anything currently available. Datasets are listed as Agent Data Cards (ADCs) — structured specifications that let an agent evaluate a dataset by task fitness, credibility, freshness, and cost before committing to a purchase. The paywalled API registry indexes services like Firecrawl, Exa, RunPod, Kling, and image generation APIs with the function schemas and pricing required for agents to call them correctly. Human data publishers can upload datasets directly to the DataHub.

The second layer is the orchestration engine. Sella maintains pipeline templates for common agentic workflows: data acquisition, model fine-tuning on rented GPU, video generation, SPA deployment. Agents do not need to figure out the sequencing themselves; they describe a task and Sella routes it through the appropriate pipeline with the right arguments at each step.

The third and most important layer is the policy engine. This is what separates Sella from a simple payment wrapper. The policy engine governs every purchase decision an agent makes: it evaluates contextual fit between the resource and the agent's current task, verifies objective alignment before any spend is committed, and supports both fully autonomous and human-assisted decision modes. An agent should not burn through a wallet buying the wrong data because a search result looked plausible. The policy engine exists to prevent that.

How I built it

I built Sella as a solo founder during the Stellar Garage builder residency in Bangalore. The frontend and API layer run on Next.js 15 deployed on Vercel, with MongoDB Atlas as the primary datastore and Cloudflare R2 for dataset storage. The MCP server is hosted on Render and is what agents interact with directly during onboarding and task execution. Wallet authentication is handled by Dynamic.xyz, session caching by Upstash Redis.

The payment layer is built on the x402 protocol over Stellar, with Solana, Ethereum, and Sui support in active development. x402 is particularly well-suited to agentic commerce because it allows an agent to attach a signed payment header directly to an API request rather than going through a separate checkout flow — the purchase and the resource access happen in a single HTTP round trip. The ADC specification was designed from scratch as a structured data format that gives agents everything they need to make a purchase decision without hallucinating context.

Challenges we ran into

The hardest problem was not technical — it was conceptual. Modelling agentic commerce behaviour from first principles required thinking carefully about what it actually means for a non-human actor to make a good purchasing decision. Human commerce has millennia of intuition behind it. Agentic commerce has none. I had to define what "contextual fit" means for a dataset, what objective matching looks like when the objective is encoded in a task prompt, and how to design the policy engine so it is genuinely useful rather than just a rate limiter with extra steps.

The second challenge was building the human-assisted evaluation mode in a way that does not break the autonomous flow. The toggle between autonomous and human-assisted cannot be a hard stop; it needs to be a graceful handoff where the agent presents a ranked proposal, waits for a signal, and resumes exactly where it left off. Getting the state management right across the MCP session, the task queue, and the dashboard required several architecture revisions.

Accomplishments we are proud of

Sella's x402 payment pipeline on Stellar testnet is fully functional end-to-end: an agent can onboard, receive a wallet, get funded, discover a dataset, pay for it in USDC, and receive the data back — entirely programmatically. The Agent Data Card specification is working accurately, with human publishers able to upload datasets that are immediately queryable by agents with structured evaluation scores. The paywalled API registry has been built and is under stress testing for discovery accuracy. Multi-chain support across Solana, Ethereum, and Sui is in active development alongside the live Stellar integration.

Building a working agentic commerce loop — not a demo, but an actual purchase pipeline with real wallets and real payment settlement — in a single residency cycle is the thing I am most proud of.

What we learned

Agents are not just automated humans. They have fundamentally different discovery, evaluation, and purchasing constraints. They cannot read a landing page, skim a pricing table, or ask a support chat. Everything they need to make a good decision has to be encoded in a structured, machine-readable format at the point of discovery. The ADC specification emerged from this constraint, and it changed how I think about what a "listing" means in an agent-native marketplace.

I also learned that the policy engine is not optional. Without it, agentic commerce degrades quickly into an agent making expensive, irrelevant purchases because the top search result had high surface-level similarity to the task. Trust in the marketplace depends entirely on agents getting consistently good outcomes, and that requires guardrails at the decision layer, not just at the payment layer.

What's next for Sella

The immediate roadmap is expanding the orchestration pipeline library. GPU rental with automated SFT job configuration, agent-to-agent hiring (where one agent can spin up and pay specialist sub-agents), and expanded paywalled API support across Firecrawl, Exa, RunPod, Kling, and image generation services are the four priorities. Each pipeline follows the same pattern: structured function arguments, policy-engine-gated purchase, invoice, payment, result. The architecture generalises cleanly.

On the infrastructure side, completing multi-chain support across Solana, Ethereum, and Sui will allow Sella to meet agents wherever their wallets already live. Longer term, the policy engine will evolve to learn from an agent's historical purchase outcomes, making recommendations that improve with every task completed.

The goal is the same as it was at the start: a marketplace where an agent can be given any complex task and find, pay for, and use every resource it needs without a human ever touching the process.

Built With

Share this project:

Updates