Introduction

What we built, and why it matters

Three platforms. One substrate. Built for a digital world that finally gives people back what's theirs.

The bigger question

For twenty years, we've built a digital economy where most of what people create flows away from them.

Your attention is captured by feeds that monetize against you. Your purchases enrich the platforms in the middle more than the makers at the ends. Your skills are bottled inside whatever certificate, transcript, or LinkedIn line a gatekeeper happens to control. Every day, ordinary people generate enormous value — and most of it is collected, summarized, and resold by someone else.

It doesn't have to be this way. Not anymore.

For the first time, the infrastructure exists to build a digital world where the proof of what you did, the value of your action, and the credit for your skill belong to you — portable, durable, and impossible to take back from you. Not metaphorically. Mathematically.

That's the world these three platforms are built for. Each one addresses a single corner of digital life where humans interact with institutions: how we participate, how we transact, and how we are recognized. Together they sketch out what a digital economy looks like when it works for the people inside it.

Three platforms, three places where it changes

1. avenued — when participation earns ownership

Today, brands extract attention from fans and return nothing. You give a brand your time, your data, your social proof, your audience — and the value flows in one direction. Algorithms monetize against you while pretending to serve you. The fan is the product.

avenued flips that. Brands stand up communities, run missions and games and predictions, and pay fans — in real money — for engagement that actually happened. Fans receive value for time they were going to spend anyway. Brands pay for completed actions, not for vague impressions. The wallet is invisible; fans log in with email. The settlement is real; every reward final and verifiable.

The human story: the economy of attention starts paying the people who supply it. Fan engagement becomes a fair trade.

2. dPlaza — commerce that doesn't skim

Stripe, Shopify, Amazon — every commerce platform in the last twenty years is structured so a middleman collects a percentage of everything that moves. Sometimes a small one, sometimes a large one, always one. The merchant takes the risk; the platform takes the rent.

dPlaza is what commerce looks like when settlement is native. Payments move in real digital dollars (USDC) on a low-cost public chain (Base). The merchant gets paid instantly, in full, without intermediaries holding the money. Digital products can mint as on-chain assets at the moment of purchase — the customer owns what they bought, the merchant owns the relationship, and the platform's job is to make this work without inserting itself into the value flow.

The human story: small operators keep the value they create. A solo merchant runs a real store and is paid like one, not like a tenant in someone else's mall.

3. studentcenter — proof of skill that can't be taken from you

A diploma is paper. A LinkedIn line is an editable text field. A certification PDF is an image file. In a world where any of these can be generated for free in seconds, the labor market has lost its lowest-trust signal — and it's the signal that matters most for people without elite networks.

studentcenter rebuilds it. Institutions — universities, training programs, employers, certification bodies — issue credentials as non-transferable on-chain proofs tied directly to the learner. The learner builds a public portfolio that any employer, anywhere, can verify in one click. No trusted middleman, no service that could go out of business and take the records with it, no platform that could change its mind. The credential is the receipt of work done, signed by the issuer, owned by the learner, verifiable forever.

The human story: what you actually learned matters again. People without elite networks can prove their skills to anyone, anywhere, and nobody can take that proof away from them.

Why this can be built now: the trust layer

For most of human history, trust required someone in the middle. A bank held the money. A registrar held the diploma. A platform held the record. You either trusted them, or you had no way to do business.

Then, quietly, in the last few years, a different way to handle trust became available — one that doesn't require a person or institution in the middle. Cryptographic proof. A small piece of mathematics that lets an issuer sign something, lets the receiver hold it, and lets anyone in the world verify it — without ever asking permission and without anyone in between able to revoke or alter it.

This isn't ideology. It isn't "Web3" in the noisy meme-cycle sense. It's just a mathematical fact that's now operationally available. Two specific pieces of it are load-bearing for these three platforms:

Stablecoins (USDC) on a low-cost public chain (Base). Real digital dollars, final settlement, costs of cents per transaction. As of 2026, the largest commerce platforms (Shopify, Stripe, Coinbase) all agree this is the rail. The infrastructure debate is over.
Wallets that hide entirely behind email login. No seed phrases, no browser extensions, no crypto literacy required. The user never knows the rails are different — they just notice that the money arrives instantly, the receipt is permanent, and nobody else is touching it.

The three platforms run on the same wallet layer and the same settlement rails. A user with an identity from one platform brings it to the next without learning anything new. The cryptographic substrate is the connective tissue — it's what makes the value durable, portable, and yours.

Why this works at human scale: AI as the operating layer

There's one more piece, and it's quieter than the first two, because we don't want it to be the headline.

A digital economy where value flows to the right people only matters if running it is affordable. For most of the last decade, that's been the problem with "platforms that work for the users" — they were too expensive to operate at small scale. A solo merchant couldn't afford the team to run a real store. A community college couldn't afford the staff to author quality learning content. A small brand couldn't run dozens of fan communities at once.

AI changes the math. Each of these three platforms is built so that the operational work — running communities, fulfilling orders, authoring lessons, generating creative — can be done by AI agents working alongside the human operator. Not replacing the person; multiplying them. The merchant focuses on craft and customer relationships while an agent handles the operational ticking. The institution focuses on what to teach while an agent helps produce the materials. The brand focuses on the community while agents help run the campaigns.

To make this work, each platform exposes its full functionality as a clean catalog of tools that an agent (or a human, or both) can call. 190 tools combined across the three platforms, every action scoped and auditable. The AI layer is what makes the verifiable economy accessible — economical at the size of a single human operator with one helper, not just enterprises with full teams.

We put AI third in this story on purpose. The first reason these platforms matter is the moral one: people should keep what they make. The second is the mathematical one: cryptographic proof makes that durable. AI is the third reason — the operational one that makes it affordable. All three are necessary. None alone is sufficient.

Three platforms, one substrate

Each platform alone is a credible product. avenued has live communities and users; dPlaza has live stores and orders; studentcenter has live institutions, learners, and credentials. Each one stands on its own.

Together, they share:

The same wallet layer. Email login. No seed phrases. The user never sees the chain.
The same settlement rails. USDC on Base. Real money, instant, low-cost, final.
The same trust layer. Cryptographically verifiable proofs that nobody can revoke.
The same operating layer. Agent-callable tool surfaces that scale the human operator without replacing them.

This means the substrate compounds. An institution onboarded to studentcenter can launch a fan community on avenued, or a merchandise store on dPlaza, on day one — same identity, same rails, same trust posture, same operational tooling. They're not a portfolio of unrelated bets. They're three points on a connected substrate that gets stronger as each one grows.

What we're not claiming

This isn't a pitch for "blockchain fixes everything" or "AI changes everything." Most of those pitches are noise.

What we're claiming is narrower and more concrete:

People should keep what they make. Their attention, their commerce, their credentials. This is the moral foundation. Without it, the other two are just clever engineering.
Cryptographic proof is the only signal that survives infinite digital generation. Issuer-signed, learner-held, anyone-verifiable. This is mathematics, not ideology.
AI agents will operate more software, and the platforms that don't expose themselves as tools will be skipped over. This is observable already; it's just a question of when the curve steepens.

None of these three platforms require the user to understand any of the above. They just work — and they work correctly in the world that's arriving.

The shape of the future we're betting on

The next economy will not be one where humans are replaced by AI, and it will not be one where everyone learns cryptography. It will be one where ordinary people keep what they make because the rails underneath finally support it — and where AI helps small operators do work that used to take teams.

Engagement that pays you back. Commerce that doesn't skim. Credentials only you can hold and anyone can verify. Built so the human side stays simple, and the machine side stays open.

Three platforms. One substrate. The connective tissue of an economy that — for once — works for the people inside it.

Portfolio Update — May 2026

Portfolio briefing — 2026-05-12

This packet covers three companies — avenued, dPlaza, and studentcenter —

built on a shared agent-operable substrate. All material is public-facing and

structured for direct use in an investor deck: each section can be lifted,

quoted, screenshotted, or paraphrased as-is. Every metric is pulled from live

production databases as of 2026-05-12; every funding figure has a cited source.

At a glance

Company	Stage	Live	Headline metric (live, 2026-05-12)	First outbound
avenued	Live, pre-revenue scaling	www.aved.ai	706 users · 18 communities · 1,236 memberships	Live with paying community pilots
dPlaza	Live, pre-revenue	platform deployed	5 stores · 11 products · live USDC checkout proven in prod	The Label Group demo sent 2026-05-07
studentcenter	Live, early commercial	studentcenter.io	7 institutions (5 enterprise-tier) · 50 members · 39 credentials minted · 14 active templates	C4Transformation outreach 2026-05-07 — paused on their side, warm

Common thread across all three

Each company ships a native MCP (Model Context Protocol) server — the same

agent-operable interface layer. 190 agent-callable tools across the portfolio

(81 + 23 + 86), all auth-scoped, all audit-logged. This is the structural bet:

every product in the portfolio is built to be operated by AI agents as a first-class

surface, not retrofit later.

avenued — 81 MCP tools, per-community scoped API keys, full audit log.

No in-product LLM calls — agent-as-operator only (the defensible shape).

dPlaza — 23-tool MCP (local + prod), three-tier auth, audit-logged writes.

Likely first commerce platform with a native MCP surface. No in-product LLM

calls — agent-as-operator only.

studentcenter — 86 MCP tools across 13 modules, role-gated per institution.

Plus heavy in-product AI: Imagen 4, Gemini 2.5 Flash TTS, 21 distinct AI route

handlers, sc_scaffold_story_game producing complete scene-mode learning games

from a single MCP call.

→ See ai-native-thesis.md for the full reasoning on why two of three deliberately

have zero LLM calls in product, and why that's the stronger investor narrative.

For an investor narrative: the moat is operability. Anyone can build a CRUD app;

none of the incumbent platforms in any of these three categories ship an

agent-operable control plane.

Per-company highlights

avenued — Base App distribution wedge in place

Coinbase Smart Wallet, OnchainKit, Basenames + USDC Checkout, CDP Paymaster

sponsorship, working Farcaster Frame v2 Mini App — all shipped 2026 YTD.

One deploy away from Base mainnet leaderboard visibility + 1–5 ETH Builder

Grants + 2 ETH/week Builder Rewards.

Multi-token rewards (AVED + USDC) live; wisdom-activity engine (prediction

markets) shipped end-to-end.

→ See avenued/avenued-investor-update.md

dPlaza — rails proven, agent-operable commerce

1,089 commits YTD · full design-system token sweep · 390px mobile depth pass

across every admin surface · RLS on 22 previously-exposed tables.

Live USDC checkout + NFT mint executed end-to-end in production.
be-dplaza persona-driven dogfooding loop (R15–R46 logged passes) — the

product audits itself.

Honest gap: pre-revenue. First outbound (The Label Group) went out 5 days ago.

→ See dplaza/dplaza-investor-update.md

studentcenter — institution control plane + AI credentialing

1,278 commits YTD on main.
5 enterprise-tier institutions live (AvenueD, TrueUp, MMBA, C4Transformation,

Student Center).

AI game authoring pipeline: institutions generate full scene-mode learning

games (TTS narration + AI backgrounds) in a single MCP call.

Honest gap: badge auto-issuance pipeline (mint trigger from completions)

is the active in-progress workstream.

→ See studentcenter/studentcenter-investor-update.md

What to use this packet for

Direct quotes: the per-company docs are public-facing; quote freely.
Metrics: all figures pulled from live production databases on 2026-05-12.

Re-pull anytime — none of this is forecast.

For visuals/screenshots: ping Jesus for product captures; not bundled here

to keep the packet text-first.

*Source: live production Supabase + git state as of 2026-05-12. Packet generated

by ohwow's local agent pipeline.*

The AI-Native Thesis Across the Portfolio

Portfolio briefing — 2026-05-12

TL;DR

All three companies (avenued, dPlaza, studentcenter) make the same structural bet from different sides: the platform itself is built to be operated by AI agents as a first-class user.

The bet is not "we sprinkled GPT into the product." The bet is that the next generation of software is operated by agents that read documentation, call tools, and chain actions — and the platforms that expose themselves cleanly as agent-callable tool surfaces will compound while CRUD-shaped competitors stay flat.

Today, across the three companies, that bet has shipped as:

Surface	avenued	dPlaza	studentcenter	Total
Native MCP tools	81	23	86	190
Auth model	Per-community `ops_api_keys`, scoped	Three-tier (superadmin / tenant / reject)	Per-institution `sc_api_keys`, role-gated	Audit-logged on every write
Validation surface	Live across 18 communities	`be-dplaza` persona dogfooding (R0–R46)	AI authors capstone games via single call	—

We are not a company that demos with AI. We are a portfolio that ships products AI can operate.

Two flavors of "AI-native"

There are two distinct shapes of AI-native software. The portfolio bets deliberately on both:

Flavor A — Agent-as-operator (avenued, dPlaza)

The product surface is a clean, scoped, audited tool catalog. A human or agent uses the same MCP to operate the platform. There is no LLM call inside the product surface — and that's the point. The platform isn't trying to be a chatbot; it's trying to be the target of agent calls.

Honest finding from the code audits:

avenued: zero openai / anthropic / gemini calls inside src/. The only LLM call in the repo is scripts/run-standup.ts (Claude over the MCP for internal dogfood).
dPlaza: same — repo-wide search for any LLM SDK returns zero hits in src/ or lib/.

Why this is stronger, not weaker:

The agent-as-operator framing is defensible. CRUD-shaped commerce platforms (Shopify, Stripe) cannot retrofit a clean tool surface without rewriting their primary product. We started from the agent surface.
It's honest with the investor. We don't claim AI features we don't have.
It compounds: every new product capability becomes a new MCP tool, and the agent's capacity grows linearly with the platform.

Flavor B — AI inside the product surface (studentcenter)

Studentcenter has the same MCP layer (86 tools) plus heavy in-product generative AI for content creation. This is the right product shape because credentialing institutions need content (lessons, games, narration, imagery), and the cost of producing it has historically been the gating factor on adoption.

Concrete integrations validated in code:

sc_scaffold_story_game (src/app/api/mcp/tools/games.ts:2055)

A single MCP call produces a complete scene-mode learning game: intro / narrative / question / remediation / results scenes, navigation triggers, score actions, optional narrator with 3 expression portraits, parallelized AI background generation, full status logging per slot. An institution admin (or their agent) goes from "I have a topic" to "playable game" in one call.

Imagen 4 background + portrait generator (src/app/lib/ai/imageGeneration.ts:17)

Calls imagen-4.0-fast-generate-001 via Vercel AI SDK. Disciplined prompt builder (imagePrompts.ts) — explicitly forbids hallucinated UI/light effects. Uploads to Supabase storage under institutions/<id>/games/<id>/ai-generated/.

Gemini 2.5 Flash TTS narration with sha256 cache (src/app/lib/ai/voiceGeneration.ts:48)

Calls gemini-2.5-flash-preview-tts. Hashes (text|voiceId) to cache against existing game_audio rows — generation is idempotent and cheap on re-runs. Wraps Gemini's 24 kHz / 16-bit / mono PCM in a 44-byte WAV header in-process (no ffmpeg dependency).

21 distinct AI route handlers (src/app/api/ai/*)

game blueprint, drill, theme, scene composition, scene triggers, element enhancement, chat-refine streaming editor, npc-chat streaming dialogue, npc-rubric, judge-submission, tag-game-skills, suggest-curricula, and more. All on gemini-3-flash-preview per routeHelpers.ts:25.

The integration isn't decorative. The whole credentialing pipeline depends on institutions being able to author content cheaply. AI authoring is the cost-curve break that lets a 50-learner community college afford to ship the same game library as a Fortune 500 corporate L&D org.

Why both flavors matter for the portfolio

The two flavors share a common substrate (MCP) but answer different markets:

Flavor A markets (avenued, dPlaza) are dense with operators — brand managers running dozens of communities, store owners running multiple SKUs across stores. The leverage is in operating the platform, not in generating content for it. Agent-as-operator wins.
Flavor B markets (studentcenter) are dense with creators — institutions producing lessons, games, badges, certifications. The leverage is in content production. AI-in-product wins.

By holding both flavors in the portfolio, the set covers both sides of the AI software transition. And because all three share the same MCP substrate, any infrastructure built (auth, audit, scoping, key rotation) compounds across all three.

Anti-patterns we deliberately avoided

A few things the codebases explicitly don't do, on purpose:

No retrofitted chatbots. None of the three products has a "chat with our AI" sidebar. We didn't add an OpenAI call to a SaaS dashboard and call it AI-native.
No hallucinated metric dashboards. Every counter in this packet is read from a production Supabase query, not fabricated by an LLM.
No "AI-generated text in customer emails" without explicit operator approval. Email builder (studentcenter/docs/EMAIL_BUILDER_SYSTEM_PLAN.md) routes through admin preview.
No outsourced agent infrastructure. Each company runs its own MCP server, on its own auth, with its own audit log. The agent layer is not delegated to a third-party platform we'd be locked into.

What this looks like in 12 months

The structural payoff:

avenued: an operator runs 50 communities by writing prompts; per-community scoped MCP keys mean one compromised key blasts radius is one community.
dPlaza: an agent stands up a complete store (theme, products, checkout, NFT mint settings) from a single prompt; persona-driven dogfooding (be-dplaza) already validates the loop.
studentcenter: an institution publishes a 12-game certification curriculum in a day; today's sc_scaffold_story_game proves the primitive works at the single-game level.

The bet pays off when "I want to launch a community / store / certification" goes from a quarter of human work to an afternoon of agent work, on a platform that already enforces the safety, scoping, and audit posture institutions / brands / merchants need.

Where this packet's evidence lives

For investor-deck use, the citations below back every claim above:

avenued MCP server — ~/Documents/avenued/src/app/api/mcp/server.ts + 9 tool modules
dPlaza MCP server — ~/Documents/dPlaza/src/app/api/mcp/server.ts (1,484 lines, 23 tools)
studentcenter MCP modules — ~/Documents/studentcenter.io/src/app/api/mcp/tools/*.ts (13 modules, 86 tools)
studentcenter AI: src/app/lib/ai/imageGeneration.ts, voiceGeneration.ts, routeHelpers.ts, src/app/api/ai/* (21 routes)
All metrics: live production Supabase queries, 2026-05-12

The codebases are private; the per-company whitepapers (v2) in this packet quote them directly. Specific files available on request under NDA.

Source: live codebase audits across all three repos, 2026-05-12.

Avenued — Investor Update (May 2026)

What it is

Avenued is a gamified brand-fan engagement platform. Brands stand up a community in minutes and run missions, games, raffles, and prediction activities; fans earn $AVED (and now USDC) rewards for participating. The model replaces opaque ad spend with pay-per-completed-action engagement, with onchain settlement abstracted behind email-based wallets.

The product today

Live at www.aved.ai. What a brand or fan can do right now:

Multi-tenant communities with admin-controlled branding, membership rules, and payment-gated access (free and paid tiers).
Missions — page-visit, social, referral, and admin-verified proof submissions, with multi-token reward support (AVED, USDC, or both).
Games — branded mini-games (e.g., Pixi Coin Catcher), bracket and parlay competitions, leaderboards.
Raffles — custom and parlay-tied draws with onchain raffle security guarantees.
Wisdom activities — prediction markets and surveys with admin-distributed rewards in AVED or USDC.
Direct rewards & messaging — admins push rewards and DMs to members; live email previews; moderation tooling.
Wallet layer — Thirdweb email/Google in-app smart wallets, plus newly-added Coinbase Smart Wallet via OnchainKit and CDP Paymaster gas sponsorship.
Base App Mini App — Avenued now runs as a Farcaster Frame v2 inside the Coinbase Base App (discover, missions, raffles, wallet views).
Avenued MCP — 81-tool MCP server lets operators (and AI agents) run any community programmatically: create missions, draw raffles, push rewards, moderate posts, pull stats. Per-community API keys with full audit logging.
Superadmin console — cross-community analytics, member search, campaign oversight.

Traction & metrics (as of 2026-05-12)

Pulled live from production Supabase.

Registered users: 706
Communities live: 18
Community memberships (user × community): 1,236
Missions created: 61
Reward allocations distributed: 90
Raffles run: 16
Wisdom activities (predictions/surveys): 19
Games published: 4

Engagement counters that are tracked per-community (mission completions, raffle entries, parlay tickets) are not exposed via the central counter tables queried for this snapshot; per-community pulls are available on request via the Avenued MCP.

2026 progress

Major shipments year-to-date, grouped by theme:

Base ecosystem integration (Q1–Q2)

Coinbase Smart Wallet wired alongside Thirdweb email/Google.
OnchainKit installed; Basenames display + USDC Checkout component live.
CDP Paymaster proxy for sponsored transactions.
Farcaster Frame v2 Mini App scaffolded with discover / missions / raffles / wallet views; base:app_id verified against base.dev.

Multi-token rewards

Schema migrations 016 + 087: missions, wisdom activities, and parlays now reward in AVED, USDC, or both simultaneously.
Dynamic token labels across user-facing reward flows; admin token selector in creation wizards.

Wisdom activities (new product surface)

End-to-end prediction/survey engine: creation wizard, allocation refactor, distribution pipeline, multiple-choice with optional custom answers, admin "set correct answer at creation" flow, distribution UI with token selector.

Parlays & brackets

External-reward proof flow (admin marks parlays externally rewarded with proof); migration 089 and admin UI; bracket data model and views.

Mission engine hardening

Page-visit mission type added with reward allocation seeding.
X-account gate scoped only to missions that require X interactions; admin warning on misconfiguration.
Wallet/Thirdweb session-expiry recovery for mission claims.
Multi-token reward wiring across the mission completion path.

Avenued MCP platform

81 tools across community, mission, raffle, reward, moderation, gmail/tasks, and stats domains.
Per-community scoped API keys (ops_api_keys) with auth.communityId enforcement and ops_audit_log on every write.
Recent additions: avenued_get_stats (with inboxOpen moderation counter), avenued_get_gmail_stats, avenued_get_upcoming_tasks, avenued_get_recent_activity, payment-txn revenue rollup.
Server refactored from monolith into thin factory + extracted tool modules.

Feed & social

Unified card styles, optimistic likes and post inserts, cross-community navigation that preserves context, performance pass on infinite-scroll animations.
Compact inline team logos for parlay cards; admin pill in social links for community admins.

Admin & operator UX

Toast/copy pass across admin surfaces (imperative copy, replaced alert() with toasts).
Live email preview in direct rewards panel.
Persistent "New Activity" picker modal and new-activity admin button.
QR-code share for community pages from admin overview.

Security & data integrity

Removed permissive RLS policies from sensitive-column tables.
Migration 017 raffle security hardening.
Migration 028 pending admin invitations; migrations 029–030 direct messaging + realtime.
Username normalization trigger to keep username_normalized in sync.

In progress / next 90 days

Active branches and in-flight workstreams:

kalshi — Kalshi-style prediction-market integration on top of the wisdom-activity engine (in-flight branch).
dev2 — ongoing platform consolidation track.
Tutorials surface — docs/tutorials/ being built out (untracked, in progress) to drive operator self-serve onboarding.
AVED on Base mainnet — Phase 2 of the Base App roadmap: deploy AVEDToken.sol and AVEDBoosts.sol to Base mainnet (8453), unlock Base leaderboard visibility and Builder Grants (1–5 ETH retroactive) + Builder Rewards (2 ETH/week).
Mini App polish & directory submission — push the Frame v2 Mini App into the Base App Mini Apps directory after the mainnet flip.
Social mission verification spectrum — ship the trust-tiered verification model (honor system → admin review → referral-graph → API-verified) so brands can run X/Instagram/YouTube/Discord missions without per-platform OAuth blocking launch.
Client-account operations — clients/ folder is now a first-class tracking surface; agency-style account management of communities running on the platform is being formalized.

Vision / why it matters

The digital ad economy extracts attention from users and returns nothing. Avenued flips that: brands pay only for completed engagement, and the budget converts directly into rewards the fan actually receives. The combination of (a) no-code campaign tooling for brands, (b) email-based smart wallets that hide Web3 entirely from the fan, and (c) an MCP-native operations layer that lets a single operator or AI agent run dozens of communities, makes the model economically defensible at small scale and operationally leveraged at large scale.

The Base App integration is the distribution wedge: Avenued is positioned to be one of the first gamified-engagement Mini Apps inside Coinbase's consumer Base App, with USDC rails already live and AVED mainnet next.

Avenued — Whitepaper v2.0 (May 2026)

Abstract

Avenued is a multi-tenant brand-fan engagement platform where brands stand up a community in minutes and run missions, games, raffles, and prediction activities; fans earn AVED and USDC for participating, with onchain settlement abstracted behind email-based smart wallets. The platform is built from the ground up to be operated by AI agents as a first-class user surface: every operator action — creating a mission, drawing a raffle, pushing a reward, moderating a post, pulling stats — is exposed as a tool through a community-scoped MCP server. The structural bet is that one operator plus an agent can run dozens of communities at the unit economics of a single SaaS seat, which is what makes the model defensible at small scale and leveraged at large scale.

Live at www.aved.ai with a Farcaster Frame v2 Mini App inside the Coinbase Base App, Coinbase Smart Wallet via OnchainKit, CDP Paymaster gas sponsorship, and an 81-tool MCP API in production.

The problem

Brand-fan engagement is structurally broken in two directions at once.

On the fan side, the digital ad economy extracts attention from users and returns nothing measurable. Loyalty programs reduce to discounts. "Community" reduces to a Discord server nobody opens. Web3 was supposed to fix this and instead added a wallet-shaped wall that filtered out everyone who wasn't already crypto-native.

On the brand side, every brand now needs a community, but no brand has the headcount to run one well. Running a real engagement loop — designing a mission, funding the reward pool, verifying completions, distributing tokens, moderating posts, drawing a raffle, answering DMs — is a full-time job per community. Multiply that by a portfolio of brands and an agency runs out of people before it runs out of demand.

The thesis: AI agents can run the operational layer of a community competently if and only if the platform is built to expose itself as tools, with the same auth model and audit guarantees a human operator would have. Most consumer software is built to be clicked, not called. Avenued is built to be called.

What Avenued is today

A multi-tenant SaaS platform where:

A brand creates a community, configures branding, membership rules, and (optionally) a paid tier.
A fan onboards with an email — a smart wallet is created in the background — and joins one or more communities.
The community admin (human or agent) configures and runs missions (page-visit, social, referral, admin-verified proof), wisdom activities (predictions, surveys, multi-choice with optional custom answers), parlays and brackets (tournament-style competitions), raffles (custom or parlay-tied), and games (Pixi-based mini-games).
Rewards flow as AVED, USDC, or both. Onchain settlement is abstracted behind the wallet layer; sponsored gas via CDP Paymaster means the fan never sees a network fee.
Distribution: directly at aved.ai, and as a Farcaster Frame v2 Mini App rendered inside the Coinbase Base App.
Operation: through the admin console at /<community-slug>/admin/*, or programmatically through the Avenued MCP.

Architecture

Stack

App: Next.js 16 App Router, TypeScript strict, Tailwind, Framer Motion, Zustand. (package.json → next@^16.1.6, react@^18.3.1.)
Data: Supabase Postgres with RLS, separate staging/prod. Schema in sql_current/ (canonical CREATE state) and sql/ (incremental migrations through 090_fix_sensitive_rls_policies.sql).
Wallet layer: Thirdweb (thirdweb@^5.110.3) for email/Google in-app smart wallets, plus Coinbase Smart Wallet via OnchainKit (@coinbase/onchainkit@^0.38.19) and CDP SDK (@coinbase/cdp-sdk@^1.48.2).
Onchain settlement: blockchain/contracts/AVEDBoosts.sol (Solidity) — hybrid design where tokens are locked onchain for boost tiers and multiplier logic is computed off-chain. ReentrancyGuard, Pausable, Ownable. Target network: Base. AVED token contract itself is not in this repo — it is deployed externally and integrated by address.
Multi-tenant routing: dynamic [community_slug] segment in src/app/[community_slug]/ resolves every page (community home, missions, raffles, admin) per community.
Server actions: src/app/actions/ — 30 domains including missions, wisdom, parlays, brackets, raffles, rewards, messaging, treasury, webhooks, referrals.
API surface: src/app/api/ — mcp, ops/* (the REST counterparts to MCP tools), paymaster (proxy to CDP_PAYMASTER_URL), webhooks/payment, cron/bracket-sync, auth/linkedin, x-auth, dplaza/user-info.

Base App / Farcaster Frame v2 Mini App

src/app/mini/ is a parallel route tree built for in-frame rendering inside the Coinbase Base App:

mini/discover — discoverable community surface
mini/missions — fan mission flow
mini/raffles — raffles in-frame
mini/wallet — wallet view scoped to mini-app context
MiniAppProvider.tsx — supplies walletAddress / isConnected from the host frame to child screens, decoupled from the main aved.ai Thirdweb-backed auth

base:app_id metadata is emitted server-side (verified at src/middleware.ts) so base.dev recognizes the property.

Multi-token reward model

The reward model used to be AVED-only. As of migrations 016_multi_token_rewards.sql, 087_wisdom_multi_token.sql, and 088_wisdom_both_token.sql, missions, wisdom activities, and parlays can each reward in AVED, USDC, or both simultaneously. The admin token selector is wired through the creation wizards; the mission completion path was rewritten end-to-end to carry the token choice through allocation, distribution, and the user-facing reward label.

Security and integrity posture

RLS policies on sensitive-column tables tightened (090_fix_sensitive_rls_policies.sql).
Raffle security hardening in 017_raffle_security.sql (advisory locks + uniqueness on winner rows, see 082_raffle_results_unique_winner.sql).
Reward-pool freeze pathway (067_reward_pool_freeze.sql) and circuit-breaker status surfaced through the MCP (avenued_get_circuit_breaker_status).
ops_audit_log (024_ops_audit_log.sql, expiry rules in 070) records every write made through the ops API or MCP.

AI-native layer

This is the structural bet.

The Avenued MCP

The platform exposes itself as 81 tools (counted in src/app/api/mcp/tools/*.ts as of commit 98041995). Tools are organized across nine domains:

Domain	File	Representative tools
Platform activity & operations	`tools/activity.ts`	`avenued_create_community`, `avenued_onboard_community`, `avenued_pause_community`, `avenued_suspend_user`, `avenued_freeze_pool`, `avenued_get_platform_health`, `avenued_get_circuit_breaker_status`, `avenued_get_gmail_stats`, `avenued_get_upcoming_tasks`, `avenued_get_recent_activity`, `avenued_list_underfunded_communities`, `avenued_list_unfunded_active_missions`, `avenued_list_stale_raffles`, `avenued_fund_community`, `avenued_create_faucet_wallet`
Stats	`tools/stats.ts`	`avenued_get_stats` (with `inboxOpen` moderation counter), `avenued_list_communities`, `avenued_list_users`
Missions	`tools/missions.ts`	`avenued_list_missions`, `avenued_create_mission`, `avenued_update_mission_status`, `avenued_archive_mission`, `avenued_list_mission_entries`, `avenued_list_mission_submissions`
Raffles	`tools/raffles.ts`	`avenued_create_raffle`, `avenued_draw_raffle`, `avenued_get_raffle_winners`, `avenued_archive_raffle`
Parlays	`tools/parlays.ts`	`avenued_set_parlay_results`, `avenued_select_parlay_winners`, `avenued_get_parlay_winners`
Tournaments / brackets	`tools/tournaments.ts`	`avenued_get_tournament`, `avenued_get_tournament_leaderboard`, `avenued_get_tournament_winners`
Members	`tools/members.ts`	`avenued_list_members`, `avenued_search_members`, `avenued_add_member`, `avenued_update_member_role`
Content & moderation	`tools/content.ts`	`avenued_list_posts`, `avenued_moderate`, `avenued_get_moderation`, `avenued_list_reported_comments`, `avenued_send_email`, `avenued_announce`, `avenued_update_community_visuals`
Rewards & treasury	`tools/rewards.ts`	`avenued_send_direct_reward`, `avenued_send_bulk_reward`, `avenued_allocate_pool`, `avenued_withdraw_from_treasury`, `avenued_get_top_earners`, `avenued_get_behavior_analytics`, `avenued_get_treasury_balance`, `avenued_get_pending_transfers`

The server is a thin factory (src/app/api/mcp/server.ts, ~140 lines after the d47da0fa refactor) wrapping @modelcontextprotocol/sdk. Every server.tool call is monkey-patched to:

Run inside an AsyncLocalStorage context that records { toolName, params, write }.
Emit structured logs on every call with duration, status, communityId, apiKeyId, superadmin.
Persist every write call to ops_audit_log keyed by API key and community.

Auth model

Defined in src/app/api/ops/auth.ts:

Superadmin tier — bearer token equals OPS_API_KEY (single env var). Cross-community visibility; community_id parameters are optional. Used internally and for the daily standup script.
Community tier — bearer token resolves to a row in ops_api_keys (022_ops_api_keys.sql, expiry rules in 070_ops_audit_log_and_key_expiry.sql, nullable scope in 089_ops_api_keys_nullable_scope.sql). Scoped to exactly one community; the MCP layer enforces auth.communityId so a community key physically cannot read or write data outside its row. Keys have read or read+write scope and an expiry.

Operators create keys in-product at /<community-slug>/admin/automations, copy them out, and either paste them into their own agent's config or use them with the Avenued MCP server URL (https://www.aved.ai/api/mcp).

What the agent-operability bet means in practice

The same surface area a human admin would click — create a mission, fund a pool, draw a raffle, moderate a flagged post, push a direct reward to a member, pull treasury balance, send a templated email — is callable as an MCP tool with identical auth and audit semantics. An AI agent can run a community without a UI; a human operator can run dozens of communities by delegating routine work to an agent and only reviewing the audit log.

This is why "AI-native" in Avenued's case is not a chatbot in a sidebar. It is the absence of any privileged path that requires a human in front of a screen.

In-product AI generation: explicit non-claim

A direct read of the code shows no first-party generative-AI calls in user-facing flows today. The only Anthropic SDK usage is scripts/run-standup.ts, a dev/ops utility that drives a daily platform standup report (model claude-sonnet-4-6) using the MCP itself as the tool surface — an operator using its own product. There is no OpenAI / Gemini / Replicate / ElevenLabs integration in the application code. Image-gen for raffles, copy-gen for missions, and AI moderation are not shipped features today; if and when they are added, they will sit behind the same MCP boundary, which means an agent can offer them or operators can swap in their own model without coupling the product to a single provider.

This is a deliberate design — Avenued is the target of agent calls, not the source. The model wrapper lives outside the trust boundary.

The reward economy

Tokens

AVED — native engagement token. Lives outside this repo as a deployed ERC-20 (target: Base mainnet, see roadmap below). Used for mission rewards, raffle prizing, wisdom-activity payouts, and as the locked asset in AVEDBoosts.sol.
USDC — first-class reward token alongside AVED as of migration 016. Brands fund pools in USDC, fans receive USDC, and OnchainKit's USDC Checkout component is wired into the wallet/checkout flows.

Reward primitives can carry either token or both at once, so a single mission can pay 100 AVED + 1 USDC per completion.

Boost mechanism

AVEDBoosts.sol lets a holder lock AVED for 30/90/180 days against a tier multiplier. Lock state is the only thing onchain. The multiplier-to-reward computation is off-chain (in the application), which keeps gas costs predictable and lets the platform evolve multiplier curves without a contract upgrade. Emergency unlock with a penalty exists; the contract is Ownable, Pausable, ReentrancyGuard.

Wisdom activities

A whole product surface that didn't exist when the previous whitepaper was written. Wisdom activities are prediction markets and surveys: an admin authors a question with a set of outcomes (multi-choice with optional custom answers), allocates a reward pool, and at resolution time distributes payouts to members who picked the correct outcome. End-to-end wired through:

Schema: 018_wisdom.sql, 087_wisdom_multi_token.sql, 088_wisdom_both_token.sql
Server actions: src/app/actions/wisdom/ (10 actions: create, distribute, resolve, getAdmin, getRanked, submit, update, updateStatuses, getGlobal)
Admin UI: src/app/[community_slug]/admin/wisdom/

19 wisdom activities have been published in production as of 2026-05-12.

Parlays, brackets, raffles

Parlays and brackets give fans tournament-style competitions (pick the winners across a set of matchups). Schema: 007_parlays.sql, 010_brackets.sql, plus 089 for the external-reward proof flow that lets admins mark a parlay as externally rewarded with proof. Custom and parlay-tied raffles are in 013_custom_raffles.sql and 014_parlay_raffles.sql. The raffle-draw path is locked behind 017_raffle_security.sql (advisory lock, unique winner) and exposed via avenued_draw_raffle in the MCP.

Traction

Live numbers pulled from production Supabase on 2026-05-12:

Registered users: 706
Communities live: 18
Community memberships (user × community): 1,236
Missions created: 61
Reward allocations distributed: 90
Raffles run: 16
Wisdom activities: 19
Games published: 4

Per-community engagement counters (mission completions, raffle entries, parlay tickets) are tracked on the community row but not surfaced in this central rollup; they are pullable per-community through avenued_get_community_overview and avenued_get_community_growth.

Roadmap

Tracked against active branches and in-flight workstreams.

kalshi branch — Kalshi-style prediction-market integration on top of the wisdom-activity engine. Currently mock data at src/app/kalshi-demo/; the real integration sits behind the wisdom schema so existing distribution and audit semantics carry forward.
dev2 branch — ongoing platform consolidation track, not yet merged.
AVED on Base mainnet — Phase 2 of the Base App play: deploy the AVED ERC-20 and AVEDBoosts.sol to Base mainnet (chain ID 8453). Unlocks Base App leaderboard visibility, Builder Grants (retroactive 1–5 ETH), and Builder Rewards (2 ETH/week recurring while active).
Mini App directory submission — after mainnet flip, submit the Frame v2 Mini App for inclusion in the Base App Mini Apps directory.
Social-mission verification spectrum — trust-tiered model (honor system → admin review → referral-graph signal → API-verified) so X / Instagram / YouTube / Discord missions can launch without per-platform OAuth blocking on day one. Schema groundwork in 078_verification_level_and_referral_missions.sql.
Tutorials surface — docs/tutorials/ for operator self-serve onboarding (in progress, currently untracked).
Client-account operations — clients/<client-slug>/ is now a first-class tracking surface (about.md, progress.md, questions.md per client); the agency-style account management of the platform's own client portfolio is being formalized in the repo.

Reconciliation with the v1 whitepaper

The v1 whitepaper (docs/whitepapers/avenued-general-whitepaper.md) was written when the product was earlier and narrower. Investor-readable diffs:

"AVED only" tokenomics → multi-token. v1 framed AVED as the singular medium of exchange. The product now supports USDC alongside AVED on every reward primitive (missions, wisdom, parlays). v1's "Sustainable Tokenomics" section understates this.
"Mission, game, leaderboard" product surface → six primitives. v1 listed missions, games, leaderboards, boosts, and a portfolio dashboard. Wisdom activities, parlays, brackets, raffles (custom and parlay-tied), direct messaging, and a moderation inbox are all live and absent from v1.
No mention of an MCP / agent-operable surface. This is the most consequential omission. The 81-tool MCP with per-community scoped keys and ops_audit_log is the structural differentiator and didn't exist when v1 was drafted.
No mention of Base App / Mini App distribution. v1 treats the product as a single web destination at aved.ai/connect. The Coinbase Smart Wallet integration, OnchainKit components (USDC Checkout, Basenames), CDP Paymaster, and the /mini/* Frame v2 surface are all v2-era.
Onboarding tagline drift. v1's "Email in. Wallet on. Time to win." is still accurate, but the wallet layer now spans Thirdweb (email/Google) and Coinbase Smart Wallet via OnchainKit, not the single-vendor implementation v1 implied.
"Boost mechanism" was an unspecified primitive. It is now a real Solidity contract (AVEDBoosts.sol) with 30/90/180-day lockups and a hybrid on/off-chain split.
"Governance participation (future implementation)" — still future. No governance code exists in the repo today; this is a stated non-shipped item, not a deprecated one.

Nothing material from v1 has been killed; the v1 framing is a strict subset of v2. The drift is one of focus: v1 reads as a token whitepaper. v2 reads as a platform whitepaper with a token, an agent interface, and a Base-App distribution channel.

Vision

The thesis is narrow and structural: the next layer of consumer software gets operated by AI agents, and the platforms that win are the ones whose entire operator surface is a typed, audited, scoped tool API on the day the agent shows up to work — not retrofit later. Avenued already has that surface, in production, with 81 tools, per-community scoping, full audit logging, and the same auth model whether the caller is a human admin clicking a button or an agent making an HTTP request.

For brands, that means a single operator (human + agent) can run a community catalog the size of a mid-tier agency book. For fans, it means the engagement loop — mission, reward, raffle, payout — happens on rails that are explicit and inspectable, in a wallet they didn't have to learn about, with rewards in a token of their choosing.

The Base App integration is the wedge: Avenued is positioned to be one of the first gamified-engagement Mini Apps inside Coinbase's consumer Base App, with USDC rails already live and AVED mainnet next. The MCP is the moat: every additional tool we ship makes the platform more leverageable per operator, and every additional operator who hooks an agent into it generates production traffic that hardens the audit and scoping model.

The old attention economy took from users. The new one rewards them, and runs itself.

Avenued — Competitive Funding Landscape (May 2026)

How we frame the competitive set

Avenued sits at the intersection of three categories investors are actively pricing in 2026: (a) Web3 community / loyalty / quest platforms, (b) Farcaster / Base App Mini App distribution, and (c) brand engagement and creator-community SaaS. Below is the set of confirmed 2026 closes in adjacent categories — money that actually landed between January and May 2026. "In talks" rounds and pre-2026 incumbents are excluded by design; they are noted only in commentary as negative-space signal. Capital is concentrated at the application layer this cycle (prediction markets, creator monetization, consumer crypto onboarding), and avenued is the only entry in the set that ships an agent-operable MCP surface across an 81-tool API.

Negative-space signal: The legacy Web3 quest-and-reward incumbents (Galxe, Layer3, Zealy) and the Web2 community-SaaS incumbents (Skool, Mighty Networks, Circle, Geneva) have no 2026 raise on record. Adjacent consumer-social plays (Towns Protocol, Neynar/Farcaster) also did not close fresh primary equity rounds in 2026. The capital is moving past them, toward consumer-app surfaces with real distribution.

Confirmed 2026 raises in adjacent categories

Web3 community / consumer-crypto / prediction-market platforms

Fun — Crypto on/off-ramp + payment rails powering Polymarket, Lighter, Aave. $72M Series A co-led by Multicoin Capital and SignalFire, closed late January 2026, announced May 1, 2026. Source: https://www.theblock.co/post/399726/crypto-onramping-solution-fun-raises-72-million-series-a-co-led-by-multicoin-capital-and-signalfire
Kalshi — Regulated prediction-market exchange (direct comparable for avenued's "wisdom activity" / prediction-market scenes). $1B round at $22B valuation, led by Coatue Management with Sequoia, a16z, Paradigm, IVP, Morgan Stanley, ARK (as reported May 8, 2026). Source: https://www.thecoinrepublic.com/2026/05/08/prediction-markets-platform-kalshi-bags-1b-funding-at-22b-valuation/
XO Market — User-generated prediction markets ("YouTube of prediction markets"). $6M seed, announced late April / early May 2026, with Coinbase Ventures, 20VC, Picus Capital, Venture Together. Source: https://www.coindesk.com/business/2026/04/30/xo-market-bets-on-user-generated-prediction-markets-to-rival-polymarket-and-kalshi

Farcaster / Base App / Mini App ecosystem

Based (Hyperliquid Super App) — Web3 trading + payments app built as a Hyperliquid super app. $11.5M Series A led by Pantera, fundraising opened Q4 2025 and closed February 2026. Source: https://www.theblock.co/post/390809/hyperliquid-web3-based-funding-pantera

Brand engagement / fan & creator community SaaS

Whop — Creator marketplace + community payments. $200M investment from Tether at a $1.6B valuation, February 2026. Closest large-scale comparable for the "monetized creator/brand community" thesis. Source: https://www.coindesk.com/business/2026/02/25/tether-invests-usd200-million-in-digital-marketplace-whop-to-expand-stablecoin-payments
Fanvue — AI-powered creator monetization platform (London). $22M Series A led by Inner Circle, announced January 12, 2026; reports $100M+ run rate. Source: https://www.businesswire.com/news/home/20260112458975/en/AI-Powered-Creator-Monetisation-Platform-Fanvue-Hits-%24100m-Run-Rate-and-Raises-%2422m-Series-A-Investment---as-Leading-Global-Creators-Rush-to-Join-the-Platform

Comparison table — avenued vs. confirmed 2026 closes

Company	Raised (2026)	Round	Stage	Distribution	Token-rewarded	Native MCP	Mini App	Fans (latest reported)
avenued	not raised yet	—	live, pre-revenue	Base App Mini App, web	Yes (AVED + USDC)	Yes (81 tools)	Yes (Frame v2)	706 users · 18 communities · 1,236 memberships
Kalshi	$1B (May 2026, as reported)	Late-stage	growth, regulated	Web + mobile, US-regulated	No (fiat)	No	No	Multi-billion lifetime volume
Whop	$200M (Feb 2026)	Strategic (Tether)	growth	Web + mobile	Stablecoin (USDT, USAT)	No	No	18.4M users
Fun	$72M Series A (closed Jan 2026)	Series A	scaling infra	API / embedded	No (infra)	No	No	$18B/yr payments
Fanvue	$22M Series A (Jan 2026)	Series A	scaling	Web (Web2)	No	No	No	17M MAU · 250K creators
Based (Hyperliquid)	$11.5M Series A (Feb 2026)	Series A	early growth	Hyperliquid super-app	Yes	No	No	n/a public
XO Market	$6M seed (Apr 2026)	Seed	early	Web + mobile	Yes	No	No	30K+ users · $150M volume

What this comparison tells us

Capital is rotating toward consumer-app surfaces with real distribution. The six 2026 closes — Kalshi, Whop, Fun, Fanvue, Based, XO Market — all share one trait: they own (or sit inside) a distribution layer. Meanwhile, the pure Web3 quest incumbents (Galxe, Layer3, Zealy) and the legacy Web2 community-SaaS layer (Skool, Mighty Networks, Circle, Geneva) did not close primary rounds in 2026. Avenued's bet on Base App Mini App distribution + Farcaster Frame v2 is aligned with where capital is moving, not where it has been.

No funded peer ships a native MCP. Across all six confirmed 2026 closes, this is the column nobody else has filled. The 81-tool MCP is what makes avenued agent-operable — brands and their agents can run a community programmatically, which is increasingly how creator/brand teams operate as AI agents are layered into marketing stacks. For investors paying attention to AI-native distribution, this is the differentiated wedge.

Valuation comparables suggest the seed band sits between $6M (XO Market) and $22M at $100M run-rate (Fanvue). Avenued is pre-revenue with 706 users and a working agent surface, so the honest comparable for a first institutional round is XO Market's $6M seed and Based's $11.5M Series A — both consumer-crypto application-layer plays with comparable early traction and a Base/Hyperliquid distribution thesis. Kalshi ($1B) and Whop ($200M from Tether) are the largest peer raises in the set and serve as signals of category strength and a "where this can scale to" ceiling, not direct round-size comparables. Fun ($72M Series A) sits in between as a scaling-infra benchmark.

The three closest peers for the deck

XO Market ($6M seed, Coinbase Ventures + 20VC) — Same distribution thesis (consumer crypto + user-generated activity), same stage, same investor profile. Most useful single comparable for a seed round.
Based ($11.5M Series A, Pantera) — Closest "consumer crypto super-app on a new L1/L2 distribution surface" comparable; signals investor appetite for application-layer plays riding a specific ecosystem's distribution.
Whop ($200M from Tether at $1.6B) — Direct comparable for the "community + payments + creator/brand monetization" thesis; useful as a "where this can scale to" data point.

Sources

dPlaza — Investor Update (May 2026)

Date: 2026-05-12 · Public-facing portfolio briefing

What it is

dPlaza is a creator-first commerce platform — a Shopify alternative for artists, labels, and innovative brands that need to sell physical goods, digital releases, and ticketed experiences from a single storefront. Every product is optionally NFT-backed on Base, with crypto and fiat checkout, so creators own their audience and IP without juggling Shopify + Bandcamp + Eventbrite + Discord.

The product today

A live multi-tenant SaaS at dplaza.io with five distinct surfaces, all in production:

Storefront builder — create-store flow, theming, custom slugs, dynamic OG metadata
Merchant admin — inventory, orders, finance/payouts, customers, emails, token-gates, collections, events, subscriptions, marketplace, creators
Customer storefront — product detail, cart, checkout (USDC + fiat), order history, profile, digital library
Superadmin — cross-store oversight (7 sections) with analytics and revenue rollups
dPlaza MCP — 10-tool Model Context Protocol server so merchants (and AI agents) can manage stores, products, orders, revenue, and pending-order inbox from Claude Code or any MCP client. To our knowledge, dPlaza is the first commerce platform shipping a native MCP surface.

Tech: Next.js 15 + Supabase + Thirdweb on Base, Magic for passwordless wallets, USDC settlement.

Traction & metrics (as of 2026-05-12)

Pulled live from production Supabase:

Stores onboarded: 5 (The Label Group, Lumira Atelier, HernanCorp, WMSMTM, OurPandaWorld)
Store admin seats: 7
Products listed: 11
Registered users: 11
Orders placed: 1 (test order on The Label Group, $35 USDC, paid + minted flow exercised end-to-end)
Active outbound pilots: 1 (The Label Group demo, sent 2026-05-07 — first dPlaza outbound; awaiting reply)
2026 YTD commits to master: 1,089
Newest store created: The Label Group, 2026-04-20

Honest read: the platform is real and the rails work (live store → cart → USDC checkout → NFT mint has been completed against prod). Commercial volume has not started — we are pre-revenue and the first outbound went out five days ago.

2026 progress

Themed view of what shipped this year (1,089 commits, all on master):

Design system & UX maturity. Built a canonical admin component library (AdminStatTile, AdminSectionHeader, AdminCard, AdminTable, AdminStatusBadge, AdminBriefHeader) and ran a token sweep across every admin surface — orders, finance, dashboard, settings, customers, billing, emails, creators, community, marketplace, expenses, inventory, token-gates, events, collections, subscriptions, payouts, onboarding, email-builder. Result: one consistent visual system, no more legacy color drift.

Mobile depth pass at 390px. Walked and fixed every admin and storefront surface for mobile: admin orders (card layout replaces 8-col table), token-gates, finance, billing, settings, customers, emails, profile, add-product wizard, marketplace. CTA visibility, tap targets, font weight normalization, overflow handling.

Persona-driven dogfooding (be-dplaza). A repeatable internal loop where the engineer plays store_creator, store_owner, customer, and superadmin, walking the full job-to-be-done (create-store → add-product → accept-payment → fulfill → withdraw) and fixing every blocker inline. 40+ logged review passes (R15 through R46) with screen-by-screen scorecards.

Brand and identity. New D logomark (r=60 TR curve, fixed corner sweeps, open counter), regenerated full favicon set, white logo + wordmark across admin navbar.

Security hardening. Row Level Security enabled on 22 previously-exposed production tables (including users). RLS gap closed.

MCP integration. Built a 10-tool MCP server with local + prod endpoints. Tools: store/product/order/merchant listing, revenue analytics (7d/30d), recent activity, pending-order inbox, Gmail stats, upcoming tasks, total users KPI. Makes dPlaza programmatically operable from any AI agent.

E2E test suite. Built and stabilized a Playwright suite covering core merchant + customer + admin flows; isolated browser contexts, global teardown, screenshot review loop. Multiple rounds of test-and-fix passes through 2026 Q1.

Checkout, orders, payments. Fixed contract init errors that were wiping store data, NFT metadata URL generation, mint bugs, checkout tax calc, payment step tokens, cart slug routing, hydration warnings, video upload limits, image hostname allowlist, order creation race conditions, refund modal.

In progress / next 90 days

First merchant live transactions. Convert The Label Group demo into a live store doing real volume; line up 2-3 more inbound prospects from the existing pipeline (Lumira Atelier and HernanCorp are already provisioned).
Subscriptions for fans, not just SaaS plans. Current subscription system is platform billing only; the fan-club/membership product for creators is the next major build.
Hybrid physical+digital products and bundles. Top gap from the current_state audit — physical and digital exist separately, the formal "buy vinyl, get NFT + gated content" SKU does not.
Token-gate authoring UI. The useTokenGate hook is shipped; the no-code authoring surface for a non-technical marketer to gate a page to a product is not.
Label / multi-store dashboard. Architecturally the platform is single-store-per-owner; a true label/parent-org dashboard with roles is the unlock for the B2B segment.
Portfolio command center wiring. dPlaza MCP feeds the cross-business dashboard at ohwow.fun (KPIs, revenue, recent activity, inbox).

GTM status

First outbound demo store sent 2026-05-07 to The Label Group — fully provisioned prod store at dplaza.io/the-label-group with TLG-branded logo, headline, and roster framing. Awaiting reply.
Pipeline is still narrow and founder-led. No paid acquisition. The thesis is to land 2-3 anchor music/art tenants on the back of the live MCP + Web3 differentiation before opening a self-serve funnel.

Vision / why it matters

Shopify built the rails for the 2010s creator. dPlaza is building the rails for the creator who needs to sell a t-shirt, a vinyl drop, an NFT, a livestream ticket, and a gated membership from the same checkout — and increasingly wants their store to be operable by their own AI agent.

Two structural bets:

Unified commerce surface beats five-tool stacks for any creator whose audience expects both physical and digital scarcity.
Agent-native commerce (MCP-first) is where new merchants will live in 24 months. Being the first platform an AI agent can natively run a store on is a defensible position, not a feature.

The product is in production, the rails are proven end-to-end, and the next 90 days are about converting the first real merchants and closing the three remaining feature gaps (fan subscriptions, hybrid SKUs, label dashboard) that gate the B2B segment.

dPlaza — Whitepaper v2.0

Agent-operable commerce on Base

Date: 2026-05-12

Status: Production · pre-revenue · first outbound 2026-05-07

Abstract

dPlaza is a multi-tenant commerce platform for creators and brands selling a unified mix of physical goods, NFT-backed digital releases, and gated experiences from a single storefront. Settlement happens in USDC on Base (mainnet) or Base Sepolia (test), wallets are passwordless via Magic SDK, and every product can optionally be NFT-backed through Thirdweb-deployed ERC-721 / ERC-1155 collections. The differentiator versus Shopify, Bandcamp, and Eventbrite stacks is not the storefront — it is the dPlaza MCP server: a 23-tool JSON-RPC surface that lets an AI agent operate a store (list and update orders, invite admins, pull revenue, manage API keys, walk the inbox) over the same primitives the humans use. Today the platform runs 5 production stores, 7 store-admin seats, 11 products, 11 registered users, and has processed 1 paid USDC order end-to-end (mint included). Commercial volume has not started — the first outbound demo (The Label Group) went out 2026-05-07.

The problem

Commerce tooling is fragmented and CRUD-shaped. A creator who wants to ship a vinyl drop, an NFT edition, and a livestream ticket from one identity ends up stitching Shopify + Bandcamp + Eventbrite + Discord + a wallet gateway and a fulfillment dashboard. Each tool exposes a UI to a human; none expose themselves to an agent.

The second-order problem is structural. As AI agents become the default operating layer for small businesses, the platforms they can natively drive will absorb the merchant. Stripe, Shopify, and Square have rich APIs but are CRUD endpoints, not tool surfaces — an agent has to learn each REST shape and re-implement scoping, auth, audit, and side-effects. Until a commerce platform exposes a native, scoped, tool-shaped surface, agent-driven commerce stays a stitched demo.

dPlaza's bet is that the platform should be operable by a model in the same shape a model already speaks — Model Context Protocol — and that the unified physical-plus-digital storefront is the right wedge to land that surface in real merchants.

What dPlaza is today

A live multi-tenant SaaS at dplaza.io with five distinct surfaces, all in production:

Surface	Path	What it is
Storefront builder	`/(create-store-flow)`, `/onboarding`	Create-store flow, theming, custom slugs, dynamic OG metadata
Merchant admin	`/[store_slug]/admin/*`	Inventory, orders, finance/payouts, customers, emails, token-gates, collections, events, subscriptions, marketplace, creators, expenses, tax
Customer storefront	`/[store_slug]/...`, `/[store_slug]/checkout/*`	Product detail, cart, checkout (USDC + fiat), order history, profile, digital library
Superadmin	`/superadmin/*`	Cross-store oversight with analytics and revenue rollups across all tenants
dPlaza MCP	`/api/mcp`	23 typed JSON-RPC tools for AI agents

Stack: Next.js 16 (Turbopack, React 19), Supabase (PostgreSQL + RLS), Thirdweb v5 on Base / Base Sepolia, Magic SDK for passwordless wallet auth, Mailgun for transactional email, Vercel for hosting, Zustand for client state. Confirmed in package.json.

Live stores (5): The Label Group, Lumira Atelier, HernanCorp, WMSMTM, OurPandaWorld. The Label Group is the first outbound demo (provisioned, branded, sent 2026-05-07; awaiting reply).

Architecture

Next.js / Supabase / RLS posture

Routing is store-scoped through the [store_slug] dynamic segment. Domain logic is organized into 19 domains under src/app/domains/ (users, stores, products, orders, payments, web3, marketplace, events, subscriptions, analytics, reviews, taxes, communications, artists, venues, organizations, avenued, plus two shared modules). Each domain follows one of two templates (complex: actions/ + repository/ + services/; simple: flat actions.ts + repository.ts).

Data lives in Supabase. The schema is mastered in sql_current/ (final CREATE state, 25+ files) and incremental migrations in sql/migrations/ (currently at 039_enable_rls_users_prod.sql, the closing migration of the 2026 RLS sweep). Migrations 038_enable_rls_missing_tables.sql and 039_enable_rls_users_prod.sql enable RLS on 22 previously-exposed tables including users itself — the gap that existed under the v1 whitepaper is closed.

Smart-contract layer (USDC payment, NFT mint)

dPlaza is not its own chain. It composes Thirdweb-deployed contracts on Base:

Payment token: USDC at 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 on Base mainnet (hardcoded in src/app/domains/payments/types.ts), with a Base Sepolia equivalent under isTestEnv. Direct USDC transfers go through prepareContractCall against the ERC-20 in src/app/[store_slug]/checkout/components/useUsdcDirectTransfer.ts (customer-signed) and through Thirdweb Engine for server-signed sweeps in src/app/domains/payments/actions/payment-actions.ts and sweep-platform-fee.ts.
Product NFTs: Thirdweb TokenERC721 (single-edition drops) and TokenERC1155 (multi-edition / merch-bundle) collections, deployed per store on demand via src/app/domains/web3/services/thirdweb-service.ts and nft-collections/services/nft-collection-service.ts. The TokenERC1155 path is wired in src/app/domains/products/actions/web3-actions.ts.
Marketplace resale: Thirdweb MarketplaceV3 (referenced in src/app/[store_slug]/admin/settings/components/MarketplaceSettings.tsx) for secondary NFT listings.
Token gates: Reusable per-product gating against owned NFT collections, driven from src/app/domains/web3/token-gates/services/token-gate-service.ts and the useTokenGate hook.

Chain selection is environment-driven (NEXT_PUBLIC_ENV → testnet vs mainnet). Magic SDK provides email-OTP wallet creation so a customer never sees a seed phrase — the credit-card-feel checkout that v1 promised, now real.

Multi-tenant store model

Routes are /(s)/[store_slug]/.... Every domain repository scopes by store_id. Store admins are managed through store_admins (existing membership) and store_admin_invites (7-day SHA-256-hashed tokens; see migration 036_store_admin_invites.sql and dp_invite_store_admin in the MCP server).

Mobile depth pass + design-system tokens

The 2026 YTD work (1,089 commits to master, all on a single trunk) leans heavily on a design-system overhaul. A canonical admin component library (AdminStatTile, AdminSectionHeader, AdminCard, AdminTable, AdminStatusBadge, AdminBriefHeader) was rolled across every admin surface, and a 390px mobile pass converted 8-column tables into card layouts on orders, finance, billing, settings, customers, emails, profile, the add-product wizard, marketplace, token-gates, and events. The visual outcome is a single coherent system; the engineering outcome is that every admin page is now built from the same six primitives.

AI-native layer (the differentiator)

dPlaza ships a 23-tool MCP server. To our knowledge, it is the first multi-tenant commerce platform with a native Model Context Protocol surface. The endpoint is JSON-RPC 2.0 over HTTP in stateless mode at POST /api/mcp (src/app/api/mcp/route.ts), and the server factory is src/app/api/mcp/server.ts.

Tool inventory

All 23 tools, with auth class and side-effect class:

Tool	Auth	Read/Write
`dp_get_metrics`	Superadmin	read
`dp_list_stores`	Any (store-scoped clamp)	read
`dp_get_store`	Any (store-scoped clamp)	read
`dp_list_products`	Any (store-scoped clamp)	read
`dp_list_orders`	Any (store-scoped clamp)	read
`dp_get_order`	Any (store-scoped clamp)	read
`dp_update_order_status`	Any with write	write
`dp_list_merchants`	Superadmin	read
`dp_create_api_key`	Superadmin + write	write
`dp_get_revenue_analytics`	Any (store-scoped clamp)	read
`dp_order_stats`	Any (store-scoped clamp)	read
`dp_list_api_keys`	Superadmin	read
`dp_revoke_api_key`	Superadmin + write	write
`dp_update_store_status`	Superadmin + write	write
`dp_get_merchant`	Superadmin	read
`dp_get_store_financials`	Any (store-scoped clamp)	read
`dp_invite_store_admin`	Any with write (store clamp)	write
`dp_list_store_invites`	Any (store clamp)	read
`dp_cancel_store_invite`	Any with write	write
`dp_remove_store_admin`	Any with write (store clamp)	write
`dp_get_gmail_stats`	Superadmin	read
`dp_get_upcoming_tasks`	Superadmin	read
`dp_get_recent_activity`	Superadmin	read

(Reconciliation: prior internal copy — including the May 2026 investor update and the CLAUDE.md setup notes — described the surface as "10 tools." That number is stale. Tool count at this writing is 23, verified by grep -c 'server.tool(' src/app/api/mcp/server.ts. The whitepaper supersedes those references.)

Auth and scoping

Every request must carry a Bearer token (src/app/api/ops/auth.ts). Three tiers:

Superadmin key — the environment-level OPS_API_KEY. Full read + write across all stores. Wired to the cross-business dashboard at ohwow.fun.
Tenant API key — provisioned via dp_create_api_key, stored in ops_api_keys as a SHA-256 hash. Scoped to a single store_id and a permissions array (read, write). Every read tool clamps to that store; every write tool asserts both write permission and store ownership before touching the database. last_used_at is updated on every call.
No-auth requests are rejected at the route boundary.

Every write tool flips an AsyncLocalStorage flag and lands a row in ops_audit_log (migration 033_ops_audit_log.sql), capturing api_key_id, is_superadmin, store_id, tool_name, params, status, error, duration, and request id. Read tools log to stderr only.

`be-dplaza` persona-driven dogfooding (R15 → R46)

The agent-operability story is not theoretical. There is an internal loop (be-dplaza skill) where the engineer-as-agent assumes one of four personas — store_creator, store_owner, customer, dplaza-owner / superadmin — and walks the full job-to-be-done: create-store → add-product → accept-payment → fulfill → withdraw. Each session lives under ux-sessions/<date>-<persona>/ with a STATUS.md punch list and screen-by-screen scorecard.

There are 18 dated session directories spanning 2026-04-17 → 2026-04-18 (plus April plumbing sub-runs for treasury-sweep, store-balances, payout-metrics, sweep-observability), and review rounds R0 through R46 are referenced across notes — i.e. forty-seven discrete walk-throughs that found and fixed real bugs inline (contract init wiping store data, NFT metadata URL generation, mint race conditions, checkout tax calc, cart slug routing, refund modal, hydration warnings, video upload limits, image hostname allowlist, etc.). This is the validation that the agent surface drives the same flows the humans drive.

In-product AI — honest current state

There is no LLM call in the product surfaces today. A repository-wide search for openai, anthropic, @ai-sdk, gemini, replicate, claude-, gpt- returns zero hits inside src/ or lib/ (the only matches are in scripts/ and docs/ tooling, not the runtime). No product-description generator, no theme generator, no support agent, no embeddings index. The AI-native story today is agent operability via MCP, full stop. In-product generative features are a 2026 H2 build, not a current claim.

The commerce primitive

USDC checkout + NFT mint is proven end-to-end in production.

The customer connects (Magic email OTP), funds a Base wallet, signs a USDC ERC-20 transfer via useUsdcDirectTransfer, the order moves through pending → paid via on-chain confirmation against payment_reference (the tx hash; REAL_TX_HASH = /^0x[a-f0-9]{64}$/i).
If the product carries a Thirdweb NFT collection, the server-side mint flow in src/app/domains/web3/actions/ issues the NFT to the buyer wallet; mint errors land on the order_items.mint_error column (migration 028_order_items_mint_error.sql).
A platform-fee sweep (src/app/domains/payments/actions/sweep-platform-fee.ts) takes the take-rate off the merchant balance, and store withdrawals settle through the store_withdrawals tables and RPCs (migrations 017, 025, 029).
"Bypass" orders (no real on-chain hash) are filtered out of every revenue and order count in the MCP layer, so investor-facing KPIs cannot be polluted by test or admin-created records.

To date the system has processed one real, paid USDC order ($35, The Label Group), with the mint path exercised. That is the proof-of-life — and the honest revenue line.

Traction

Pulled live from production Supabase, 2026-05-12:

Stores onboarded: 5 — The Label Group, Lumira Atelier, HernanCorp, WMSMTM, OurPandaWorld
Store admin seats: 7
Products listed: 11
Registered users: 11
Orders placed: 1 ($35 USDC, paid + minted)
2026 YTD commits to master: 1,089
Newest store created: The Label Group, 2026-04-20
First outbound: The Label Group demo, sent 2026-05-07 (awaiting reply)

Honest read: the rails are real and have moved real money on chain, but commercial volume has not started. The first outbound went out five days ago.

What shipped in 2026 YTD (themed)

Security hardening. Row-Level Security closed on 22 previously-exposed production tables, including users. Migrations 038 and 039 are the final sweep. This is the gap that existed under v1 and is now closed.

Design system + mobile depth pass. Canonical admin component library and 390px walk across every admin and storefront surface.

Persona-driven dogfooding. be-dplaza skill, 18 logged sessions, R0–R46 review rounds, screen-by-screen scorecards.

MCP integration. 23 typed tools, local and prod endpoints (.mcp.json references http://localhost:3000/api/mcp and https://www.dplaza.io/api/mcp). Audit log on every write. Tenant + superadmin auth.

E2E test suite. Playwright (playwright.config.ts, playwright.mcp.config.ts) over core merchant + customer + admin flows with isolated browser contexts, global teardown, screenshot review loop.

Checkout, orders, payments, mint. Hardening passes for contract init errors that were wiping store data, NFT metadata URL generation, mint failures, checkout tax calc, payment step tokens, cart slug routing, hydration warnings, video upload limits, image hostname allowlist, order creation race conditions, refund modal.

Brand and identity. New D logomark, full favicon regeneration, white logo + wordmark across admin navbar.

Reconciliation versus Whitepaper v1.0 (July 2025)

The v1 document was a positioning piece written before the platform was operable; the v2 reflects what the code actually does.

Drifted claims corrected.

"10-tool MCP" (in CLAUDE.md, the .mcp.json setup notes, and the May 12 investor update) → 23 tools, verified by static count of server.tool(...) in src/app/api/mcp/server.ts.
"Unified shopping cart for physical and digital items in a single transaction" (v1) → partially true. Physical-only and digital-only flows are live; the formal hybrid SKU ("buy vinyl, get NFT + gated content" as one line item) was explicitly removed in migration 013_remove_hybrid_product_type.sql and is on the 90-day roadmap, not in the product today.
"Powerful analytics dashboard," "in-depth analytics," "customer behavior insights" (v1) → admin has revenue rollups, order stats, and a finance section, but the deep behavioral analytics implied by v1 (cohorts, funnels, attribution) is not built. What exists is a clean operational dashboard, not a BI surface.

New surfaces v1 did not anticipate.

dPlaza MCP server (entire AI-native layer)
USDC settlement on Base, with Magic passwordless wallet onboarding
Thirdweb-deployed per-store NFT collections (ERC-721 / ERC-1155) and MarketplaceV3 secondary listings
Token-gated content and checkout (useTokenGate, TokenGatedCheckout.tsx)
Superadmin cross-store console
22-table RLS posture (v1 ran without)
Persona-driven dogfooding methodology (be-dplaza)
Operational primitives: store withdrawals, platform-fee sweep, ops audit log, tenant API keys, store-admin invites with hashed tokens
AvenueD integration (engagement layer; migration 012_avenued_integration.sql)
Tax management (migration 005_add_tax_management.sql, 019_tax_management.sql)
Expenses tracking (migration 004_add_expenses_table.sql, 018_expenses.sql)

Deprecated / dropped from v1.

"Hybrid" product type — removed by migration 013_remove_hybrid_product_type.sql. The marketing concept survives; the column does not.
"Subscription Plans" framed as platform tiers (Free / Pro / Enterprise) — the implemented subscriptions domain is product-side (fan memberships against creators), not platform billing tiers. v1's pricing tiers are not in code.
"Discord community" referenced as a v1 channel — there is no Discord integration in the codebase.
"@dPlaza_io Twitter" — not load-bearing; mentioned for reconciliation.

Roadmap (next 90 days)

Concrete, gated by what is missing in code today:

First merchant live transactions. Convert The Label Group demo into a real volume tenant; bring Lumira Atelier and HernanCorp from provisioned to live.
Fan subscriptions (product-side). The platform-billing subscription system is shipped; the creator-to-fan membership product is the next major build.
Hybrid physical+digital SKU. Re-introduce the "vinyl + NFT + gated content" line item as a first-class bundle, building on existing collection + token-gate primitives.
Token-gate authoring UI. The useTokenGate hook is shipped; a no-code authoring surface for non-technical marketers is the gap.
Label / multi-store dashboard. Architecture is single-store-per-owner; a true label / parent-org dashboard with roles unlocks the B2B segment. (The organizations domain is the foundation; migration 011_add_organizations.sql, 010_organizations.sql.)
MCP write coverage. Today's 23 tools lean read. The next pass adds dp_create_product, dp_update_product, dp_fulfill_order, and dp_initiate_withdrawal to close the loop so an agent can drive create-store → add-product → accept-payment → fulfill → withdraw end-to-end against the MCP surface alone.
Portfolio command center. The MCP feeds the cross-business dashboard at ohwow.fun (KPIs, revenue, recent activity, pending tasks). Wiring is in flight.

Vision

Shopify built the rails for the 2010s creator. dPlaza is building the rails for the creator whose audience expects both physical scarcity and digital scarcity from the same checkout — and whose store is increasingly operated by their own AI agent.

Two structural bets:

Unified physical + digital + experiential commerce beats five-tool stacks for any creator whose audience is one community across formats.
Agent-native commerce (MCP-first, scoped tool surfaces, audit-logged writes) is where new merchants will live. Being the first platform that an AI agent can natively run a store on is a defensible position, not a feature — and it is the same through-line as avenued (agent-driven engagement) and studentcenter (agent-driven credentialing) across the portfolio.

The product is in production, the on-chain commerce primitive is proven, the agent surface is shipped, and the next phase is converting the first real merchants and closing the three feature gaps — fan subscriptions, hybrid SKU, label dashboard — that gate the B2B segment.

_This document supersedes Whitepaper v1.0 (July 2025). Metrics are point-in-time as of 2026-05-12; tool counts and migration references are anchored to commit-state on that date._

dPlaza — Competitive Funding Landscape (May 2026)

How we frame the competitive set

dPlaza is an agent-operable commerce platform: multi-tenant stores, USDC checkout via Thirdweb settling on Base, NFT mint on checkout, and a 23-tool native MCP server with three-tier auth (superadmin / tenant-scoped / reject). It is, as far as we have found, the first commerce platform shipping a native MCP server as a primitive rather than a bolt-on.

That position straddles four 2026 fundable categories:

Web3 / crypto commerce + USDC checkout — stablecoin checkout, on-chain settlement, NFT issuance.
Agent-operable / AI-native commerce — MCP servers, agent payment rails, AI shopping agents, programmatic commerce.
Headless / next-gen commerce platforms — the post-Shopify primitive.
NFT mint-on-purchase / digital goods commerce — on-chain receipts, tokenized goods.

Below is the strict set of confirmed 2026 closes in adjacent categories — pre-2026 incumbents (Crossmint, Skyfire, Medusa, Saleor, Zora, Reservoir, Manifold, Highlight, Bitski) and non-raise events (Shopify+Coinbase USDC-on-Base; Coinbase x402 launch) are excluded but worth flagging as negative-space signals — the category-defining 2026 moves are partnerships and product launches, not new equity into legacy NFT/headless commerce.

2026 raises in adjacent categories

Web3 / crypto commerce + USDC checkout

Rain — $250M Series C, $1.95B valuation (Jan 9, 2026). Led by ICONIQ; Sapphire, Dragonfly, Bessemer, Galaxy, FirstMark, Lightspeed, Norwest. Stablecoin payments infra for enterprises (cards, on/offramps, cross-border). Third round in under a year. (theblock.co, prnewswire)
Circle — $222M ARC token presale at $3B FDV (announced May 11, 2026 Q1 earnings call). BlackRock, a16z crypto, ARK Invest. Funding the agentic-commerce layer on top of USDC; Q1 2026 USDC circulation $77B (+28% YoY), on-chain volume $21.5T (+263% YoY). (pymnts.com)

Agent-operable / AI-native commerce

Spangle AI — $15M Series A (Jan 7, 2026). Led by NewRoad Capital Partners; Madrona, DNX, Streamlined. Ex-Amazon team (CEO Maju Kuruvilla, formerly Bolt). AI-generated per-customer storefronts for REVOLVE, Steve Madden, Alexander Wang, WHP Global. $21M total. (geekwire.com, businesswire)
Sapiom — $15M Seed (Feb 5, 2026). Led by Accel; Okta Ventures, Array, Menlo, Anthropic, Coinbase Ventures. Payment rails so AI agents can autonomously buy software, APIs, compute. Founder Ilan Zerbib was Shopify Director of Engineering, Payments. (techcrunch.com)
Lemrock — €6M / ~$7M Seed (Mar 11, 2026). Led by Galion.exe. Connects retailer catalogues directly into ChatGPT, Claude, Perplexity for in-agent purchase. 60+ brands (Maisons du Monde, Cdiscount, Darty). (eu-startups.com, thenextweb.com)

Headless / next-gen commerce platforms

Cart.com — $180M growth round (Mar 4, 2026). Led by Springcoast Partners; existing PayPal Ventures, Arsenal Growth, Mercury Fund, Oak HC/FT. Crossed $1B total funding. Use of funds: "commerce operating system" + agentic AI for inventory/fulfillment. Closest "AI-commerce-OS" framing to dPlaza, but logistics-heavy and enterprise. (digitalcommerce360.com, retailtechinnovationhub)

Comparison table — dPlaza vs. funded peers

Company	Raised (2026)	Round	Native MCP	USDC checkout	NFT mint on order	Multi-tenant SaaS	Stores live
dPlaza	not raised yet	—	Yes — 23 tools, 3-tier auth	Yes (Thirdweb on Base)	Yes	Yes	5
Rain	$250M	Series C	No	Adjacent (issuance/cards)	No	No (B2B infra)	n/a
Circle (ARC)	$222M presale	Token / strategic	No	Underlying issuer	No	No (issuer)	n/a
Cart.com	$180M	Growth	No (agentic AI, not MCP)	No	No	Yes	enterprise
Spangle AI	$15M	Series A	No	No	No	Yes (storefront layer)	REVOLVE, S. Madden, A. Wang
Sapiom	$15M	Seed	Adjacent (agent-buys-tools rails)	Stablecoin-capable	No	No (infra)	n/a
Lemrock	€6M / ~$7M	Seed	No (catalogue-into-LLM, not MCP server)	No	No	Yes (60+ brands)	60+

What this comparison tells us

Native MCP is dPlaza's standout. Across all six funded 2026 peers — including the largest agent-commerce raises (Spangle, Sapiom, Lemrock) — none ship a native MCP server. Lemrock pipes catalogues into ChatGPT/Claude as a vendor; dPlaza exposes the merchant stack itself as MCP tools any agent can drive. Sapiom is closest in spirit (agent payments) but is infra-for-agents, not a merchant platform.
Agent-commerce capital is concentrating in the payments/identity layer (Sapiom alone $15M in 2026, on top of pre-2026 Skyfire/Basis Theory/Nekuda rounds). dPlaza is one of the only players below the platform layer also exposing the merchant action surface to agents, not just the wallet.
The stablecoin-checkout thesis is now mainstream: Rain's $1.95B valuation and Circle's $222M ARC presale at $3B FDV validate exactly the rail dPlaza already runs in production. dPlaza's edge is that the agent layer is wired through that rail from day one, not retrofitted.
Peers are ahead on capital and brand reach. Spangle ships to REVOLVE; Lemrock to 60+ EU retailers; Cart.com is at $1B+ raised. dPlaza is pre-revenue, 5 live stores, 1 test order ($35 USDC), first outbound (The Label Group) sent 2026-05-07. The investability thesis is category positioning + technical primitive, not current traction.
Negative-space signal. No new 2026 equity into legacy NFT-commerce (Zora, Reservoir, Manifold, Highlight, Bitski) or headless (Medusa, Saleor). The category-defining 2026 moves there are partnerships and product launches (Shopify+Coinbase+Stripe USDC-on-Base, Coinbase x402) rather than fresh rounds — the clean lane of "every order produces a verifiable on-chain receipt / collectible, driven by agents" is structurally under-occupied.

Sources

Rain Series C: https://www.rain.xyz/resources/rain-raises-250m-series-c-to-scale-stablecoin-powered-payments-infrastructure-for-global-enterprises ; https://www.theblock.co/post/384910/rain-valuation-nears-2-billion-usd-series-c-250-million-raise ; https://news.crunchbase.com/fintech-ecommerce/rain-series-c-funding-valuation-crypto-stablecoin/
Circle ARC presale + USDC growth: https://www.pymnts.com/earnings/2026/circle-chases-agentic-growth-scale-stablecoin-infrastructure/
Spangle AI Series A: https://www.geekwire.com/2026/former-amazon-execs-raise-15m-for-agentic-commerce-startup-that-uses-ai-to-generate-custom-storefronts/ ; https://www.businesswire.com/news/home/20260108311127/en/Spangle-AI-Raises-$15M-Series-A-as-AI-Agents-Reshape-$6.8T-Commerce-Market
Sapiom Seed: https://techcrunch.com/2026/02/05/sapiom-raises-15m-to-help-ai-agents-buy-their-own-tech-tools/
Lemrock Seed: https://www.eu-startups.com/2026/03/paris-based-lemrock-raises-e6-million-to-help-brands-sell-within-ai-agents-like-chatgpt-and-claude/ ; https://thenextweb.com/news/lemrock-raises-6m-agentic-commerce-ai-agents
Cart.com growth round: https://www.digitalcommerce360.com/2026/03/05/cart-com-180-million-funding-logistics-network-ai/ ; https://retailtechinnovationhub.com/home/2026/3/4/cartcom-pulls-in-major-investment-to-help-scale-logistics-network-and-expand-ai-capabilities

studentcenter.io — Investor Update (May 2026)

Public-facing portfolio briefing · 2026-05-12

What it is

studentcenter.io is an on-chain academic credentialing platform that lets institutions issue verifiable, NFT-backed credentials to learners and lets employers verify them on-chain in seconds. It connects three sides of the labor market — institutions, learners, and employers — through a wallet-native credential graph built on Base (mainnet) with a learning-path and badge layer on top.

The thesis: paper diplomas and PDF certificates are the wrong primitive for a job market where AI makes resumes worthless. Cryptographically verifiable, issuer-signed skill credentials are.

The product today

Three persona-scoped surfaces, all live in production:

Institution dashboard — create credential templates, deploy an ERC-721 contract per institution (Thirdweb Engine), invite learners, build curricula and learning paths, issue credentials (manual and auto), bulk-invite via CSV, and run a built-in email/automation layer. Tiered: free → pro → enterprise.
Learner portal — connect wallet, accept institution invitations, play scene-based "story games" tied to skills, complete curriculum steps, earn badges and credentials, and surface a public portfolio at /learners/[slug].
Employer portal — verify any credential by token (public verify page), browse candidates, post jobs, review applications, on-chain check of validity / revocation status.

Supporting systems shipped and in use:

Institution verification system — random-slug free tier vs. verified enterprise tier with custom slug + contract deployment unlocked.
Invitation system — full lifecycle (pending / accepted / rejected / expired / cancelled), email delivery, token-based redemption, resend/revoke from the dashboard.
Badge & learning-path engine — points-per-game, threshold-based badge issuance, multi-game capstones (e.g. AvenueD Explorer = 1 hard + 1 medium + 2 easy at ≥70%).
AI game authoring (MCP) — institutions and superadmins can scaffold story games, scenes, characters, MCQs, narration (Gemini 2.5 Flash TTS), and Imagen 4 backgrounds from a single MCP tool call. 86 MCP tools registered across 13 modules, gated by API-key role.
Marketplace — institutions can list, search, import, and clone credential templates and curricula across the platform.

Traction & metrics (as of 2026-05-12)

Pulled live from production Supabase + the in-app metrics endpoint (/api/ohwow-metrics).

Metric	Value
Institutions on platform	7 (5 verified / enterprise, 2 free)
Verified enterprise institutions	AvenueD, TrueUp Learning, MMBA, Center for Transformation, Student Center
Total members (verified, approved learners)	50
Active members	50
Active credential templates	14
Credentials minted (lifetime)	39
Learning paths configured	3
New members (last 7 days)	0
Revenue (last 30 days)	$0 (pre-monetization; pricing live, no paid conversions yet)

Note: All institutions are currently on comped enterprise (founding partners) or free tiers. Paid subscription billing infrastructure is wired but no institution has converted to self-pay.

2026 progress

Roughly 1,278 commits on main year-to-date. The shipped surface is broad; highlights:

MCP-first institution control plane — every institution gets an API key and a full Claude-callable tool catalog (learners, credentials, curricula, games, marketplace, community, emails, analytics). Superadmin-only writes are isolated by key role. This turns studentcenter into an agent-operable platform, not just a web app.
AI game authoring end-to-end — sc_scaffold_story_game produces a complete scene-mode game (scenes, layers, characters, MCQs, conditional branching, audio triggers, image backgrounds) in one call. Includes Gemini TTS narration and Imagen 4 backgrounds.
Learning Paths system (T1–T3) — merged curriculum/drills/mastery into a single Learning Paths product with per-path detail, journey graph, drag-and-drop step authoring, AI-suggested paths, course-anchored steps, mastery preview as a fictional learner, coverage health, and a cross-curriculum browser.
Skill taxonomy — hierarchical admin UI, AI skill suggestions on courses, segmented-weight SkillsLinker, bulk AI tagging queue for unmapped courses, domain normalization on slug conflicts.
Credential pipeline — full E2E issuance via MCP (sc_issue_credential), bulk issue, revoke + on-chain reflection, public verify page with revoked / valid / batch / bad-token states, manual-grant fallback.
Institution Automation tab — dedicated dashboard route exposing MCP setup prompt + API-key lifecycle (create, rotate, revoke, one-time reveal). Migrated from old Settings tab.
TalentLMS / LMS bridge — bulk sync UI to pull external courses/learners into the credential graph.
Audit + ops — ops_audit_log writes for every skill/curriculum/credential mutation, sc_audit_game + sc_audit_institution_games rollup, sc_repair_mcq_triggers for legacy game wiring.
e2e + dogfooding — Playwright fixtures with real thirdweb wallets (no auth bypass), dev-browser.sh flow for staging, dual Supabase environments (staging on Base Sepolia, prod on Base mainnet).

In progress / next 90 days

Currently dirty on main (unstaged) and on active branches:

Public institution profile redesign — full-bleed InstitutionPageShell, new LearningPathsSection, HeroSection, CredentialTemplatesSection, EnhancedCredentialCard, surfaced storyline games and credential status on the public-facing page.
Public Learning Paths route for institutions (/institutions/[slug]/learning-paths/) — new route + components in flight.
Active branches: ralph/game-builder-polish, ralph/student-progress-dashboard, plus two worktree agents — the game builder UX and the learner-side progress dashboard are next out.
Next-best-action / diagnose for institutions — sc_diagnose_institution, sc_get_next_best_action, time-series analytics tools are live; the institution-side UI is the next surface.
Paid-tier conversion — billing plumbing is in place; the next push is converting the comped enterprise institutions to self-pay, plus onboarding the GWU and Ohwow free-tier institutions.
Auto-issuance for badge capstones — AvenueD Explorer spec defines difficulty-weighted multi-game completion; spec is shipped, full auto-mint wiring is the next badge-system item.

GTM status

studentcenter has been operating in founding-partner mode through Q1–Q2 2026: 5 verified enterprise institutions onboarded on comped pricing to validate the credential pipeline end-to-end (AvenueD, TrueUp, MMBA, Center for Transformation, plus Student Center itself).

First true outbound went out 2026-05-07 to Center for Transformation (Heather + Arpan) — an onboarding-video email pitching them on moving from comped pilot to paid + expanding usage. As of 2026-05-12, C4T has paused their process on their side; the lead is on hold, not closed-lost, and we treat it as warm pipeline to revisit when their internal timing changes. The outbound itself remains useful as a template for the broader institutional sales motion (verified ed-tech orgs, certification bodies, workforce nonprofits).

The wedge: institutions already issuing certificates (PDFs, LMS badges) are the cheapest sale — we replace the PDF with a verifiable NFT credential and the LMS gradebook with a public portfolio, without changing their authoring workflow. AI game authoring (MCP) is the long-pole differentiator that no other credentialing vendor has.

Vision / why it matters

The labor market is decoupling from the resume. AI can generate any document, falsify any claim, and pass any interview screen. The signal that survives is issuer-signed, cryptographically verifiable proof of skill tied to a learner's wallet — not an email address, not a LinkedIn profile, not a PDF.

studentcenter is building the credential graph that connects:

Institutions that already do the work of teaching and evaluating, but whose outputs (diplomas, certificates, LMS badges) are unverifiable downstream.
Learners who carry their proof of skill in a wallet they own, portable across employers and platforms.
Employers who need to verify, at scale, what a candidate can actually do — in seconds, on-chain, without phoning a registrar.

The platform is opinionated about three things:

Per-institution ERC-721 contracts on Base — credentials are issuer-controlled, revocable, and on-chain native, not entries in a vendor's database.
Skill-graph–native authoring — every credential is anchored to a hierarchical skill taxonomy, every game tagged, every curriculum step weighted. The credential is a claim about a skill, not a brand.
Agent-operable platform — institutions can run their credentialing operation via MCP, which is the right shape for a world where institutions are small and AI-leveraged, not large and staff-heavy.

The bet is that in 5 years, the credential layer of the labor market looks more like ENS + on-chain attestations than like Parchment or Credly — and that the platform that owns the issuer relationship, the skill taxonomy, and the authoring tools will own that layer.

studentcenter.io: The Credential Layer for an AI-Native Labor Market

On-Chain Academic Credentialing for Institutions, Learners, and Employers

Version 2.0

Date: 2026-05-12

Executive Summary
The Problem: Resumes No Longer Carry Signal
The studentcenter.io Solution
Product Surfaces and Core Loop
Technical Architecture
The MCP Layer and AI-Native Authoring
Business Model
Go-to-Market and Current Traction
Roadmap
Vision

Executive Summary

studentcenter.io is an on-chain academic credentialing platform that connects three sides of the labor market — institutions, learners, and employers — through a wallet-native credential graph built on Base. Institutions issue verifiable, soulbound (non-transferable) ERC-721 credentials from a per-institution contract; learners hold those credentials in a wallet they own; employers verify validity and revocation status on-chain in seconds.

The thesis is simple. Paper diplomas, PDF certificates, and LMS gradebook entries were designed for a labor market in which forging documents was difficult and reference-checking was slow but reliable. Generative AI has collapsed both assumptions. Resumes, cover letters, transcripts, and even interview answers can now be fabricated at zero cost. The signal that survives is cryptographically verifiable, issuer-signed, wallet-bound proof of skill.

Key highlights as of 2026-05-12:

7 institutions on the platform (5 verified enterprise, 2 free tier).
50 verified, approved learners across those institutions.
39 credentials minted lifetime against 14 active templates.
3 learning paths configured, with a difficulty-weighted multi-game capstone (AvenueD Explorer) shipped at schema and template layer.
Approximately 1,278 commits on main year-to-date across a broad, production-deployed surface.
A native MCP (Model Context Protocol) control plane registering 86 agent-operable tools across 13 domain modules, role-gated by API-key permission — the differentiator no other credentialing vendor has shipped.
An AI authoring pipeline that scaffolds a complete scene-mode story game — including Imagen 4 background generation, Gemini 2.5 Flash TTS narration with on-disk caching, and per-character portrait synthesis — in a single tool call.

studentcenter.io is operating in founding-partner mode: enterprise institutions are onboarded on comped pricing while the credential pipeline is validated end-to-end. The billing surface (Thirdweb CheckoutWidget paying USDC on Base to the platform wallet) is wired and in production; paid-tier conversion is the next commercial milestone, not a future build.

The Problem

Credentials Are Broken in Three Directions

1. For employers, the resume is no longer signal.

A candidate can generate a polished resume, a tailored cover letter, a portfolio site, a LinkedIn profile, and answers to a take-home in minutes — at any claimed skill level. Phone-based reference checks against a registrar do not scale to the volume of applications a modern role receives. The hiring funnel is drowning in plausibly-formatted output with no underlying proof.

2. For institutions, certificate issuance is unverifiable downstream.

Universities, certification bodies, bootcamps, and corporate L&D teams already do the hard work of teaching and evaluating. But their outputs — PDFs, LMS badges, gradebook entries, paper diplomas — sit inside vendor databases or learner inboxes. There is no public, durable way for a third party to confirm "Institution X issued credential Y to learner Z on date D, and it has not been revoked."

3. For learners, the proof of work is locked in the wrong places.

A graduate's credentials are scattered across the issuing institution's LMS, a Credly-style vendor account, a PDF in their downloads folder, and a LinkedIn entry that anyone can fabricate. None of it is portable in the cryptographic sense. None of it is the learner's to control.

The Surviving Signal

The signal that survives a labor market saturated with AI-generated documents has three properties:

Issuer-signed — a known institution attested to it.
Cryptographically verifiable — verification does not depend on contacting the issuer.
Wallet-native — the learner holds the artifact in an address they control, portable across employers and platforms.

That is the artifact studentcenter.io is building.

The Solution

studentcenter.io is opinionated about three things.

Per-institution soulbound ERC-721 contracts on Base.

Every verified enterprise institution gets its own contract deployed via Thirdweb Engine, not a shared platform contract. The contract is SoulboundCredential.sol (see contracts/SoulboundCredential.sol) — an OpenZeppelin-derived ERC721 + ERC721URIStorage + AccessControl implementation that explicitly overrides transfer to revert on anything other than mint or burn, making every credential permanently bound to the original recipient's wallet. Issuance is gated by MINTER_ROLE; revocation is on-chain and reflected back into the credential graph; batched mints are capped at 100 per transaction.

Skill-graph–native authoring.

Every credential template anchors to a hierarchical skill taxonomy (sql_current/92-skill-graph.sql and 100-skill-curricula.sql). Every game, scene, and curriculum step is tagged with one or more skills at weighted strengths. The credential is a claim about a skill, not a brand badge — which makes credentials comparable, queryable, and stackable across institutions.

Agent-operable platform.

Every institution receives an API key and a full MCP tool catalog covering learners, credentials, curricula, games, marketplace, community, emails, and analytics. Institutions in 2026 are increasingly small and AI-leveraged rather than large and staff-heavy; the right shape for their credentialing operation is a tool catalog an agent can drive, not a 12-tab admin panel a registrar has to click through.

Product Surfaces and Core Loop

studentcenter.io ships three persona-scoped product surfaces, all live in production today.

Institution Admin

Authenticated via Thirdweb wallet (src/app/hooks/auth/useAuth), the institution admin can:

Create credential templates anchored to skills.
Deploy a per-institution soulbound ERC-721 contract via Thirdweb Engine (sc_setup_institution_wallet, sc_deploy_institution_contract).
Invite learners individually or in bulk via CSV through a tokenized invitation lifecycle (sql_current/13-institution-invitations.sql).
Build curricula and multi-step learning paths with drag-and-drop step authoring.
Issue credentials manually, in bulk, or via auto-issuance from learning-path completion.
Author scene-based "story games" tied to skills — manually, via in-product AI assistants, or via the one-shot MCP scaffolder.
Run a built-in email + automation layer for learner outreach (Mailgun-backed, src/app/lib/email/).
View analytics — at-risk learners, curriculum funnels, credential issuance rates, scene drop-off on games.
Manage MCP API keys with create / rotate / revoke and a one-time reveal (/institutions/[slug]/dashboard/automation).

Institutions exist in one of two tiers: a free tier with a randomly-generated slug (inst-{8-char}) and platform-shared infrastructure, or a verified Pro/Enterprise tier with a custom slug and contract deployment unlocked.

Learner

The learner connects a wallet (no email/password account required), and from there can:

Accept institution invitations via tokenized links.
Browse the catalog of skills and credentials.
Play scene-based story games tied to specific skills, with a configurable pass threshold (default 70%).
Complete multi-step learning paths and curricula.
Earn badges as point thresholds are met within a path.
Receive a credential mint to their wallet upon meeting template requirements.
Surface a public portfolio at /learners/[username] that any employer can link to.

Employer

The employer's surface is intentionally light:

A public verification page that resolves any token ID against the on-chain contract and returns valid / revoked / batch / invalid-token states.
A candidate browser tied to the credential graph.
A job-posting and application-review flow.
On-chain re-verification at any time — no registrar phone call, no PDF inspection.

The Core Loop


  Institution admin                 Learner                       Employer
       │                              │                              │
       ▼                              ▼                              ▼
  Template ──► Curriculum ──► Game/Path completion ──► On-chain mint ──► Verify
       ▲                              │                              │
       └────────── Skill graph ───────┴──── Public portfolio ─────────┘

An institution authors once, a learner completes, a credential mints to their wallet, and an employer verifies — without any party trusting a third party's database.

Technical Architecture

Stack

Framework: Next.js 16 (App Router), TypeScript strict mode, React 19.
Database: Supabase (PostgreSQL) — staging and production are separate projects. Schema in sql_current/ (canonical) plus incremental migrations in sql/.
Blockchain: Base mainnet (production) and Base Sepolia (staging), via Thirdweb (smart contracts, server wallets, Engine, CheckoutWidget).
Smart contract: contracts/SoulboundCredential.sol — soulbound ERC-721 with role-gated mint, on-chain revocation, batch-issuance cap of 100.
State: Zustand client-side stores; server actions as the primary API layer.
Auth: Thirdweb wallet-based authentication; the platform does not use Supabase Auth. RLS policies are permissive at the database layer (USING(true) WITH CHECK(true)); permission checks live in server actions using the service role.
AI provider: @ai-sdk/google + @google/genai. Default text model gemini-3-flash-preview (src/app/lib/ai/routeHelpers.ts:25); image model imagen-4.0-fast-generate-001; TTS model gemini-2.5-flash-preview-tts.
MCP: @modelcontextprotocol/sdk v1.29; endpoint at /api/mcp.
Animations and UI: Framer Motion + GSAP, Tailwind on a dark default theme; Konva-based scene canvas.

Credential Pipeline

A credential template is authored by an institution and stored in Supabase with its skill anchors, requirements, and metadata. On issuance — manual, bulk, or auto from a learning-path capstone — the platform:

Resolves the recipient's wallet address.
Calls the institution's soulbound ERC-721 via Thirdweb Engine using the institution's provisioned server wallet.
Writes the resulting token ID, transaction hash, and issuance metadata back to Supabase.
Logs the mutation to ops_audit_log with actor (user_id, API key, IP) and payload.
Optionally triggers a learner email through the integrated Mailgun-backed email layer.

The public verify route renders all four states (valid, revoked, batch-mixed, invalid token) — every state was driven through the UI during the credential lifecycle audit (audit-cred-11 through audit-cred-17).

Subscription and Billing

There is no Stripe integration. Subscription payments flow on-chain:

Pricing constants live in src/app/types/payment.ts: Pro $79/mo or $799/yr; Enterprise $249/mo or $2,499/yr; Employer Premium $10/mo or $100/yr; per-tier credential-limit envelopes (free: 20, pro: 100, enterprise: 250) per month.
The Pro/Enterprise upgrade and renewal components (src/app/components/features/institutions/ProUpgradeComponent.tsx, RenewSubscriptionComponent.tsx) embed Thirdweb's CheckoutWidget configured for USDC on Base, settling to a fixed platform wallet (0x373120ac2A48D9c2F667f94769fc87EF03c61106).
The onSuccess handler captures the transaction hash and calls upgradeToProSubscription(institutionId, billingPeriod, txHash) (src/app/actions/institutions/subscriptionActions.ts), which validates a /^0x[a-f0-9]{64}$/ hash, sets subscription_tier, subscription_expires_at, and resets reminder flags.
A cron route at /api/cron/subscription-check runs downgrade_expired_subscriptions and sends 7-day and 1-day expiry reminders through the Mailgun email service.

This means the entire monetisation path — checkout, settlement, expiry, reminders, downgrade — runs without a payment processor.

Institution Verification

Institutions begin free-tier with a random slug and platform-shared infrastructure. Verification unlocks:

A custom slug.
Provisioning of a Thirdweb Engine server wallet.
Deployment of the institution's dedicated SoulboundCredential contract.
Public visibility in the institution directory.
Contract-level credential issuance.

The verification workflow is request → admin review → tier change → wallet setup → contract deploy. Both the dashboard UI and the superadmin MCP catalog (sc_verify_institution, sc_setup_institution_wallet, sc_deploy_institution_contract, sc_update_institution_tier) drive the same server actions.

Invitation System

A full lifecycle invitation primitive backs institution and employer onboarding: pending, accepted, rejected, expired, cancelled; tokenized redemption URLs; email delivery; resend and revoke from the dashboard; cleanup triggers and audit hooks at the database layer; and a registration path that auto-resolves role assignments for users invited before they existed in the system (sql_current/13-institution-invitations.sql).

Badge Spec and Learning Paths

Learning paths group games and curriculum steps under a point-weighted threshold; hitting the threshold issues a badge. The schema (sql_current/77-badge-learning-paths.sql) ships learning_paths, learning_path_games, user_game_completions, issued_badges, and per-path badge_difficulty_requirements (hard / medium / easy game counts and minimum pass score).

A meta-badge — the AvenueD Explorer capstone (template 1d5031d4-e3b8-4226-a2fe-869a7c1b5811) — composes 4 games at minimum 70% pass score: 1 Hard, 1 Medium, 2 Easy. The capstone spec is shipped end-to-end at the schema and template layer; the auto-issuance trigger that listens to user_game_completions and writes into issued_badges is currently in progress. Honest gap: as of 2026-05-12, user_game_completions and issued_badges both hold zero rows — the pipeline is wired in code and seeded with the right shape, but the game-pass → completion-row → threshold-check → on-chain badge mint loop has not yet generated production volume. All 39 credentials minted to date were either manual or template-issuance, not capstone-driven.

Story Games (Scene-Mode)

Story games are the primary learner-facing assessment surface. Schema lives in sql_current/16-game-scene-builder.sql: a game is a sequence of game_scenes; each scene composes scene_layers, which compose scene_elements (text, character, button, nav_button, drag_item, drop_zone); elements carry element_triggers, which fire trigger_actions (navigate, score, narrate, advance, dispatch, expression-flip). Multi-choice questions wire to scenes via correct/incorrect triggers and a configurable scoring model. A learner's pass is recorded against the game's tagged skills, which roll up into both badges and credential eligibility. game_characters carry neutral / happy / concerned portrait URLs; game_audio carries background music, correct/incorrect cues, victory, fail, and per-scene narration tracks.

Audit and Operations

Every skill, curriculum, credential, and game mutation writes to ops_audit_log (sql_current/90-ops-audit-log.sql) with actor (user_id, API key, IP) and payload. The MCP audit interceptor (src/app/api/mcp/server.ts:54-100) wraps every tool handler transparently and only persists rows for write-flagged tools. Bulk diagnostics (sc_audit_game, sc_audit_institution_games) surface legacy MCQ wiring, dangling navigation, unparseable conditions, and missing skill anchors; the idempotent repair tool (sc_repair_mcq_triggers) rewires legacy mcq_option triggers to match the canonical scaffolder output. The platform is designed to be debugged from the agent layer, not by hand.

The MCP Layer and AI-Native Authoring

The defining technical decision of studentcenter.io is that every institution is also an MCP server endpoint. The Model Context Protocol implementation exposes 86 tools across thirteen domain modules, role-gated by API-key permission. Tool registration (not just the handler) is conditional — institution keys never see superadmin tools in tools/list, and superadmin keys see the full surface.

Tool Catalog — 86 tools across 13 modules

Counted directly from registration calls in src/app/api/mcp/tools/:

Module (file)	Tools	Tier
`tools/shared.ts`	12	superadmin + institution (auto-scoped per institution)
`tools/institution.ts`	12	superadmin + institution
`tools/games.ts`	19	superadmin + institution
`tools/superadmin.ts`	9	superadmin only (writes)
`tools/platform.ts`	7	superadmin only (reads)
`tools/credentials.ts`	3	superadmin + institution
`tools/curriculum.ts`	2	superadmin + institution
`tools/gameOps.ts`	6	superadmin + institution
`tools/learners.ts`	5	superadmin + institution
`tools/marketplace.ts`	3	superadmin + institution
`tools/community.ts`	4	superadmin + institution
`tools/emails.ts`	2	superadmin + institution
`tools/analytics.ts`	3	superadmin + institution
Total	86

Authentication is handled by SCAuthContext (src/app/api/ops/auth); every write tool is gated by guardWrite() (server.ts:42) which both flags the audit row and enforces the write permission on the API key. Writes that act on behalf of an institution admin resolve a real user_id via lib/actor.ts::resolveInstitutionActor, so the audit log records both the API key and the human admin being acted-for, and responses include an on_behalf_of field for transparency.

A representative slice of the catalog:

Environment — sc_get_environment returns staging vs production, chain, and Supabase project ref so the agent never mutates the wrong target.
Shared read — skills, institutions, learners, credentials, templates, audit log, member stats; institution keys auto-scope every query to their own institution_id.
Superadmin writes — sc_create_institution, sc_setup_institution_wallet, sc_deploy_institution_contract, sc_verify_institution, sc_update_institution_tier, sc_create_skill, sc_revoke_credential, sc_create_api_key, sc_add_institution_admin.
Game building — scene, layer, element, trigger, action, question, option, drag-item, drop-zone, character, plus the one-shot sc_scaffold_story_game and diagnostics (sc_audit_game, sc_audit_institution_games, sc_repair_mcq_triggers).
Learner pipeline — invite, bulk-invite, approve, status updates, at-risk reporting.
Credential issuance — full E2E mint (sc_issue_credential), bulk mint, revoke with on-chain reflection.
Curriculum analytics — per-learner progress, cohort funnel, AI-driven skill recommendation for a curriculum (sc_recommend_skills_for_curriculum).
Game lifecycle — publish, unpublish, clone (game, template, curriculum), analytics (attempts, pass rate, scene drop-off).
Marketplace — search, get, import marketplace templates across institutions.
Community — subgroups, posts, pinning.
Engagement + agentic — time-series analytics, institution diagnose, next-best-action, CSV export, learner email send.

The platform ships four pre-wired MCP server configurations (.mcp.json) — sc-local-staging-superadmin, sc-local-staging-institution, sc-prod-superadmin, sc-prod-institution — so an institution operator can plug an agent into the right tier of the right environment in one step. The canonical institution setup prompt is generated by buildInstitutionMcpPrompt in src/app/lib/mcp/setupPromptTemplate.ts, with a pinning unit test guarding its single-quote escape strategy after a real regression broke onboarding.

AI-Native Authoring: `sc_scaffold_story_game`

The flagship MCP tool is sc_scaffold_story_game (src/app/api/mcp/tools/games.ts:2055-2200+). A single tool call produces a complete scene-mode story game: intro scene, 1–4 narrative scenes, 1–10 question scenes (MCQ or true/false), per-question optional Remediation scenes, two Results scenes (pass/fail), navigation triggers, score actions, optional in-scene narrator character with three expression portraits, optional per-scene Gemini TTS narration, and per-scene Imagen 4 background imagery. The output is a published-ready game tagged to the institution's skill graph.

Input shape (truncated for the essentials, full Zod schema in code):


{
  game_id: uuid,                       // pre-created via sc_create_game
  story: {
    intro_title, intro_subtitle,
    background_description?,           // → Imagen 4 prompt
    narrative_scenes: [                // 1..4
      { name, heading, body, background_description? }
    ],
    questions: [                       // 1..10
      { question_text, question_type: 'mcq'|'true_false',
        explanation?, remediation_text?,
        background_description?,
        options: [{ text, is_correct }]   // 2..5
      }
    ],
    pass_message, fail_message?,
    results_background_description?,
    auto_generate_backgrounds?,        // master switch, default true
    audio?: { background_music_url, correct_sound_url, ... },
    narrator?: {
      name, subject_description?,      // → Imagen 4 portraits
      image_urls?, voice_id?,          // Gemini voice (Kore/Puck/Charon/...)
      position?: 'right'|'left'
    },
    voiceover?: boolean,               // defaults true when narrator set
    enable_remediation?: boolean
  }
}

What it does, end to end:

Background images. For every slot lacking a background_image_url, the scaffolder builds an Imagen 4 prompt via buildGameBackgroundPrompt (src/app/lib/ai/imagePrompts.ts) — a disciplined style preset that explicitly forbids hallucinated UI elements (no fog, no orbs, no synthetic light effects) and constrains the model to light/material/atmosphere descriptors. It then calls generateAndUploadImage (src/app/lib/ai/imageGeneration.ts:17), which runs imagen-4.0-fast-generate-001 at 16:9, uploads the result to the Supabase public-assets bucket under institutions/<id>/games/<id>/ai-generated/<ts>-<hash>.{png|jpg}, and returns the public URL. Failures degrade gracefully — the slot falls back to its solid colour and an imageGenLog entry records the reason. All slots are generated in parallel via Promise.all.

Narrator portraits. When narrator.subject_description is provided and image_urls is not, the scaffolder generates three expression frames (neutral, happy, concerned) via buildCharacterPortraitPrompt, persists them as a game_characters row, and wires onCorrect / onIncorrect triggers on every question scene to flip the active expression.

Narration. When voiceover is true (default when a narrator is set), generateSceneNarration (src/app/lib/ai/voiceGeneration.ts:48) calls gemini-2.5-flash-preview-tts for each narrative and question scene. The function ships its own micro-cache: it computes sha256(text|voiceId) and short-circuits to the existing game_audio row when a previous run already produced the same artifact, so re-scaffolding the same content costs zero TTS calls. Gemini returns raw 24 kHz / 16-bit / mono PCM, which the function wraps in-process with a 44-byte WAV header (no ffmpeg dependency) before uploading.

Scene + element + trigger graph. The scaffolder writes scenes in canonical order (intro → narrative_i → question_i → optional remediation_i → results-pass / results-fail), layers them (background, character, UI), creates question and option rows, and emits the full trigger graph (onSceneStart playback, onClick advance, onCorrect score+narrator-happy+advance, onIncorrect score+narrator-concerned+remediation-or-advance).

Audit trail. The whole call is one write-flagged MCP invocation. The audit row captures actor, institution, params, duration, and per-slot generation logs.

Return. The handler returns all created IDs (scenes[], questions[], options[], characters[]), imageGenLog, voiceGenLog, and any non-fatal errors, so the calling agent has enough state to continue editing without a re-fetch.

The economic point: the scaffolder collapses what is, in a Canvas or TalentLMS world, a multi-day authoring task across an LMS designer, a copywriter, a stock-image researcher, and a voice talent into a single tool call that costs roughly the price of one Imagen 4 batch plus one Gemini TTS pass per scene. Institutions that adopt MCP get to author at the marginal cost of inference, not headcount.

Other AI-Native Surfaces

The scaffolder is the headline, but AI is wired across the product surface. Every route below uses gemini-3-flash-preview unless noted:

Surface	Route / file	Function
Game blueprint generation	`src/app/api/ai/generate-blueprint/route.ts`, `generate-game/route.ts`	Generate a full game spec (title, questions, scenes) from a topic prompt
Experience blueprint	`generate-experience-blueprint/route.ts`, `generate-experience/route.ts`	Generate richer multi-step learning experiences
Drill generation	`generate-drill/route.ts`	Generate practice drills from a skill
Question authoring	`generate-questions-from-blueprint/route.ts`, `refine-question/route.ts`	Generate or refine individual quiz questions
Scene composition	`compose-scene/route.ts`, `generate-scenes-from-blueprint/route.ts`	Compose scene-mode scenes from a blueprint
Theme generation	`generate-theme/route.ts`	Generate a consistent visual theme for a game
Image generation	`generate-image/route.ts`, `bulk-image-prompts/route.ts`, `enrich-experience-images/route.ts`	Imagen 4 generation; bulk prompt enrichment; experience-level image enrichment
Trigger building	`generate-scene-triggers/route.ts`, `build-triggers/route.ts`	Generate interaction triggers between elements
Element enhancement	`enhance-element/route.ts`	Improve a single scene element's copy or styling
Conversational editing	`chat-refine/route.ts`	Streaming chat that returns structured `{ message, changes }` edits to an in-flight game
Sim authoring	`generate-sim/route.ts`	Generate interactive sim scenes
NPC dialogue	`npc-chat/route.ts` (streaming), `npc-rubric/route.ts`	In-game NPC chat; rubric grading for NPC interactions
Submission judging	`judge-submission/route.ts`	LLM-as-judge for open-ended learner submissions
Skill auto-tag	`tag-game-skills/route.ts`	Tag a game with skill slugs + weights from title/description/questions
Curriculum suggestion	`suggest-curricula/route.ts`	Suggest 3 learning paths grouping an institution's existing courses (constrained to real course IDs — never hallucinates content)

The shared pipeline lives in src/app/lib/ai/pipeline.ts, with per-domain prompt builders (gamePrompts.ts, scenePrompts.ts, themePrompts.ts, triggerPrompts.ts, elementPrompts.ts, chatRefinePrompts.ts, dslPrompts.ts, simSelectorPrompts.ts, experiencePrompts.ts) and matching Zod schemas. Streaming routes use streamText from the Vercel AI SDK; structured routes use generateText + extractJSON. Authoring tests (scripts/test-ai-*.ts) cover questions, themes, scenes, elements, and triggers as a callable regression suite.

Honest Gaps in the AI Pipeline

Auto-issuance loop is unwired. user_game_completions and issued_badges hold zero rows; the loop from game-pass → completion-row → threshold-check → on-chain badge mint is wired in schema but not yet generating production volume.
AI fraud / verification on the issuance path is not implemented. Credential authenticity rests entirely on the on-chain soulbound contract and the per-institution MINTER_ROLE. There is no AI-side anomaly detection on issuance today; the design point is that cryptographic verification makes it unnecessary at the credential layer, though it remains a fit at the attempt layer for sniffing automated game-completion.
AI in the email builder is partial. Email infrastructure ships with Mailgun delivery, templates, and the subscription/expiry/reminder service (src/app/lib/email/services/subscription.ts), but the AI-assisted compose surface is not yet AI-backed; the existing builder is template-and-snippet, not LLM-drafted.

Business Model

studentcenter.io has three revenue streams. Pricing constants and the on-chain checkout path are in production (src/app/types/payment.ts); paid conversion is the next commercial milestone, not a future build.

1. Institution Subscriptions (paid via USDC on Base)

Free — random slug, platform-shared infrastructure, 20 credentials/mo, basic templates. Entry point.
Pro — $79/mo or $799/yr — custom slug, contract deployment unlocked, 100 credentials/mo, full template authoring, full game authoring including the AI scaffolder, full MCP catalog, email + automation, learning paths, curricula, marketplace import, public directory listing.
Enterprise — $249/mo or $2,499/yr — adds 250 credentials/mo, bulk operations at scale, priority Engine throughput, advanced analytics, white-glove onboarding, and curated marketplace listing rights.

Settlement: Thirdweb CheckoutWidget, USDC on Base, settling to 0x373120ac2A48D9c2F667f94769fc87EF03c61106. No Stripe — the platform never holds card data and never owes a processor.

2. Employer Subscriptions

A single low-cost tier at $10/mo or $100/yr that unlocks the employer portal (candidate browsing, job posting, application review), verified-employer status visible to learners, and on-chain verification at scale.

Pricing is deliberately low — employers are the demand-side that pulls institutions onto the platform; volume matters more than ARPU at this layer.

3. Marketplace Revenue

Institutions can list, search, import, and clone credential templates, curricula, and story games across the platform (src/app/api/mcp/tools/marketplace.ts, src/app/marketplace/). The platform takes a cut on transacted listings; on imported templates the original author retains attribution and a recurring share. The marketplace is live; pricing logic is wired; volume to date is concentrated in free clones during founding-partner mode.

Unit Economics Direction

The pricing surface assumes a labor-market reality in which institutions number in the tens of thousands (every certification body, every bootcamp, every corporate L&D function, every credentialing nonprofit), employers number in the millions, and per-account ARPU is intentionally lower than enterprise-LMS pricing to clear the wedge: institutions paying $20,000–$200,000/year for a legacy LMS see Pro at $79/mo as a no-friction additive purchase rather than a rip-and-replace decision.

Go-to-Market and Current Traction

Operating Mode: Founding Partners

studentcenter.io has been operating in founding-partner mode through Q1 and Q2 2026. Five verified enterprise institutions were onboarded on comped pricing to validate the credential pipeline end-to-end:

AvenueD
TrueUp Learning
MMBA
Center for Transformation (comped enterprise institution; commercial conversion paused per their internal timing)
Student Center (the platform's own institution)

Two free-tier institutions sit alongside them. All paid-tier billing infrastructure is in place (USDC-on-Base checkout, expiry cron, downgrade RPC, reminder emails); no institution has converted to self-pay yet, which is the explicit next commercial milestone.

Metrics Snapshot (2026-05-12)

Pulled from production Supabase and the /api/ohwow-metrics endpoint.

Metric	Value
Institutions on platform	7 (5 verified enterprise, 2 free)
Verified enterprise institutions	AvenueD, TrueUp Learning, MMBA, Center for Transformation, Student Center
Total members (verified, approved learners)	50
Active members	50
Active credential templates	14
Credentials minted (lifetime)	39
Learning paths configured	3
`user_game_completions` rows	0 (auto-issuance loop wired, not yet generating volume)
`issued_badges` rows	0
New members (last 7 days)	0
Revenue (last 30 days)	$0 (pre-monetization; pricing live, no paid conversions yet)
Commits on `main` YTD	~1,278
Registered MCP tools	86 across 13 modules

The numbers are deliberately read in their context: the shipped surface is broad and production-deployed, the credential pipeline mints real soulbound NFTs to real wallets on Base mainnet, the institution roster is small and intentionally curated, and the conversion-to-paid step is unblocked but not yet pulled.

The Wedge

Institutions already issuing certificates — PDFs, LMS badges, paper diplomas — are the cheapest sale. studentcenter.io replaces the PDF with a verifiable soulbound NFT credential and the LMS gradebook with a public learner portfolio, without changing the institution's existing authoring workflow. Their teaching, evaluation, and content authoring stay where they live; studentcenter.io adds the credential layer on top.

AI game authoring (the MCP scaffolder) is the long-pole differentiator that opens the upsell from "your existing certificate, now verifiable" to "your existing certificate plus a scene-based skill game we generated for you in one tool call, with narration and art included."

Roadmap

Next 90 Days

Badge auto-issuance pipeline — closing the loop from game-pass → user_game_completions row → threshold check against badge_difficulty_requirements → on-chain badge mint. Schema and template are shipped (the AvenueD Explorer capstone); auto-mint wiring is the work.
Public institution profile redesign — full-bleed InstitutionPageShell, new LearningPathsSection, HeroSection, CredentialTemplatesSection, EnhancedCredentialCard; surfacing storyline games and credential status on the public-facing institution page. In flight on main.
Public learning-paths route at /institutions/[slug]/learning-paths/ — new components and routes in flight.
Game-builder UX polish (ralph/game-builder-polish) — making the scene-mode editor self-service for non-technical institution admins.
Learner-side progress dashboard (ralph/student-progress-dashboard) — surfacing per-learner curriculum and path progress.
Next-best-action surface for institutions — sc_diagnose_institution, sc_get_next_best_action, and time-series analytics tools are live in MCP; the institution-side UI consuming them is the next dashboard surface.
Paid-tier conversion — billing plumbing is in place; the push is to convert the comped enterprise institutions to self-pay and to upgrade the free-tier institutions through verification.

6–12 Months

AI game library expansion — scaling the marketplace from dozens to hundreds of skill-tagged story games, with institution authoring rate as the primary input.
Employer-side acceleration — converting the employer surface from "verification utility" into a candidate-discovery product on top of the credential graph.
Cross-institution stacking — credentials from multiple institutions composing into super-credentials (e.g. a learner who holds Institution A's "AI Brief" and Institution B's "Workforce Edge" earns a third-party meta-credential), enabled by the shared skill taxonomy.
Public credential-graph queries — opening read-only credential-graph APIs to third parties (ATS vendors, agent frameworks, recruiting platforms) on a usage-priced basis.
AI authenticity layer at the attempt boundary — adding lightweight anomaly detection at the game-completion boundary (timing fingerprints, answer-pattern entropy) so that the soulbound credential at the end of the funnel reflects a real human attempt, not a scripted one. Cryptographic verification still covers issuance; this hardens the input.

Vision

The labor market is decoupling from the resume.

AI can generate any document, falsify any claim, and pass any interview screen that does not bind to a verifiable artifact. The signal that survives this transition is issuer-signed, cryptographically verifiable proof of skill tied to a wallet the learner owns. The platform that owns the issuer relationship, the skill taxonomy, and the authoring tools owns the credential layer of the labor market.

studentcenter.io is building that platform.

Institutions already do the work of teaching and evaluating; their outputs need to become verifiable downstream. Learners need to carry their proof of skill in something more durable than a PDF and more portable than a LinkedIn profile. Employers need to verify, at scale, what a candidate can actually do — in seconds, on-chain, without phoning a registrar.

The bet is that in five years, the credential layer of the labor market looks more like ENS and on-chain attestations than like Parchment or Credly — and that the platform that ships the credential primitive, the skill graph, and the agent-operable authoring catalog before its incumbents notice the shape of the new market is the platform that owns the layer.

studentcenter.io is the early form of that platform: shipped, in production, minting soulbound NFTs on Base mainnet, with an 86-tool MCP control plane no incumbent has built, and the institution roster already growing.

For more information:

Platform: https://www.studentcenter.io
Founding institution example: https://www.studentcenter.io/institutions/avenued
Contact: dbuidler@dcommunity.io

This document is the v2.0 canonical whitepaper for studentcenter.io. Features, metrics, and roadmap items reflect the state of the platform as of 2026-05-12 and are subject to change as the platform evolves. Technical claims are cited to specific files in the production codebase; metrics are pulled from the production Supabase and the /api/ohwow-metrics endpoint.

studentcenter.io — Competitive Funding Landscape (May 2026)

How we frame the competitive set

studentcenter.io is the only platform that fuses soulbound on-chain academic credentials with AI-native learning-game authoring and an agent-operable MCP surface. No single funded peer holds all three primitives at once.

Below is the strict set of confirmed 2026 closes (Jan–May 2026, equity rounds only — no M&A, no 2025 rebrands) across adjacent categories. Credentialing incumbents (Credly/Pearson, Accredible, BCdiploma, Sertifier, Hyperstack), AI-learning peers that closed in 2025 or earlier (Oboe, MagicSchool, Kyron, Synthesis), LXP incumbents (Docebo, 360Learning, Cypher), and workforce upskillers (Multiverse, Guild) are excluded. The negative-space signal is large: across the entire credentialing + LXP layer there is essentially no fresh equity in 2026; the AI-learning side is where the capital concentrated (Gizmo, Oboe-late-2025, Emversity).

Confirmed 2026 raises in adjacent categories

Gizmo — AI-powered study tool (notes → flashcards/quizzes/games), 13M users. $22M Series A on April 15, 2026 led by Shine Capital with Ada Ventures, Seek, GSV, and NFX. TechCrunch · Axios Pro · PRNewswire
Emversity — Indian employability + embedded campus skilling platform. $30M Series A in January 2026 led by Premji Invest with Lightspeed and Z47. 4,500 learners across 40 campuses; healthcare and hospitality verticals. Entrackr · YourStory · Entrepreneur India
Boundary Labs (no live site) — $2M pre-seed (2026) led by Galaxy Ventures with First Block Capital and BlackWood to launch USBD, a verifiable stablecoin on Ethereum. Tangentially related (verifiable-data infra). Phemex

Comparison table — studentcenter vs. funded 2026 peers

Company	Raised (2026)	Round	Soulbound credential	On-chain mint	AI game / course authoring	Native MCP / agent surface	Institutions live
studentcenter.io	not raised yet	—	Yes (ERC-721 soulbound)	Yes (Base, USDC)	Yes (`sc_scaffold_story_game`, Gemini 2.5 Flash TTS + Imagen 4)	Yes (86 tools / 13 modules)	7 (5 enterprise-tier)
Gizmo	$22M (Apr 2026)	Series A	No	No	Partial (study materials, not narrative games)	No	0 (B2C, 13M learners)
Emversity	$30M (Jan 2026)	Series A	No	No	No	No	40 Indian campuses
Boundary Labs	$2M (2026)	Pre-seed	No	Yes (stablecoin infra)	No	No	0 (verifiable-data infra)

What this comparison tells us

The intersection of "institution-issued soulbound on-chain credential" + "AI game authoring" + "agent-operable MCP" is empty among funded 2026 peers. Each of the three companies that actually closed equity in 2026 holds at most one of those primitives.

Gizmo ($22M Series A) is the cleanest AI-native edtech comparable — but it's B2C study-tool authoring, no credentialing layer, no on-chain mint, no MCP.
Emversity ($30M Series A) owns institutional/employer GTM in India — but no on-chain layer, no AI game authoring, no agent-callable surface.
Boundary Labs ($2M pre-seed) has verifiable on-chain infra for stablecoins — adjacent verifiable-data plumbing, but no academic credentials and no learning content.

studentcenter.io is the only platform where an institution admin can spin up a learning game in one MCP call, mint a soulbound ERC-721 to a learner on Base via Thirdweb USDC checkout, and let an employer verify the credential on-chain — all from agent-callable tools. The 2026 funding evidence shows the market is paying for each leg of this stool individually. studentcenter is the bundle.

Headline market signals from 2026 raises:

AI learning content / authoring is the most fundable lane in 2026 (Gizmo $22M Series A April 2026 is the cleanest comparable for AI-native edtech).
Workforce credentialing still attracts the largest single tickets (Emversity $30M Series A Jan 2026).
The credentialing incumbents are not raising — they are being absorbed. Acquisition is the exit path; studentcenter is positioned to be the next-generation incumbent target.