PlayHunch future roadmap.

Last updated: May 26, 2026

PlayHunch should become the social trading layer for prediction markets: every high-signal X post, token launch, ecosystem milestone, unlock, liquidity event, and crypto narrative can become a tradable, self-resolving market in seconds.

The current product already has the right primitives: a mobile swipe surface, one-tap /quick bets, Privy-authenticated wallets, USDC settlement, proof cards, a Twitter agent, Supabase persistence, an admin dashboard, and the first standalone token market. The next stage is not "add more pages." It is to turn PlayHunch into the opinion-to-liquidity engine for crypto.

The bullish version:

• X becomes the market creation and acquisition surface.
• PlayHunch becomes the execution, wallet, portfolio, and proof layer.
• Tokens, apps, founders, protocols, and narratives get continuous markets around their maturity.
• Creators and agents can launch markets without waiting for a centralized venue to list them.
• Every trade creates a receipt, every resolution creates a shareable proof, and every proof feeds the next market.

PlayHunch is already beyond a concept. The repo has shipped foundations that are unusually strong for a young prediction-market product:

• Social Swipe Arena: mobile-first swipe markets with visible YES/NO odds.
• Best-exec routing: venue abstraction, quote fanout, split routing, receipt ledger, and saved-cents proof.
• One-tap bet path: /quick/[marketId] already accepts side, size, venue, and referral context from Twitter, Telegram, and Frames.
• Twitter agent: tagged posts are parsed into market-search facets, routed across venues, reranked, and replied to with YES/NO quick links.
• Wallet and money path: Privy auth, Circle wallets, USDC balance reads, low balance recovery, idempotent swipes, and LLM isolation from execution.
• Proof surfaces: /proof/[swipeId], portfolio, leaderboard, admin metrics, funnel counters, and agent logs.
• Standalone market primitive: the $HUNCH $10M market proves PlayHunch can own first-party markets with fee disclosure, a resolution source, a special page, a trade API, and database tables.

That foundation points to one direction: generalize the standalone market into a market factory, then wire it directly into X.

PlayHunch should make the internet tradable without making the user feel like they are using a trading terminal.

The North Star user action:

1. A user sees a high-signal X post.
2. They tag @playhunchxyz or use a Hunch-enabled post template.
3. Hunch turns the claim, token, chart, or narrative into a market.
4. The reply/post itself shows live YES/NO prices and two actions.
5. The user taps YES or NO, confirms with their Hunch wallet, and the position is live.
6. The agent monitors, explains, resolves, claims, and generates a proof card.
7. The proof card goes back to X and starts the next loop.

In one sentence: X is where opinions start; Hunch is where opinions become liquid.

• Be social-native first. The product should feel born inside X threads, not bolted onto them.
• Prefer self-resolving crypto-data markets. Crypto events are measurable by code: market cap, liquidity, holder count, volume, unlocks, listings, TVL, revenue, burns, developer activity, governance outcomes, and onchain flows.
• Turn trust into a product surface. Every market needs clear resolution rules, sources, deadlines, odds history, trade receipts, and proof cards.
• Keep the agent in the loop, not in the money path. The agent finds, explains, ranks, monitors, and resolves. Deterministic code executes.
• Build the creator loop early. If users and creators can launch markets, the catalog grows faster than any internal curation team.
• Keep token-adjacent energy product-first. Do not lean on "buy," "pump," or fake airdrop hints. The bullish story is usage, market creation, opinion liquidity, fees, proof, and community ownership.

$HUNCH should not feel like a side quest. It should become the coordination asset around PlayHunch's market network: creation, curation, reputation, incentives, fee flow, and community ownership.

The product should design toward these utility paths:

• Market creation credits: creators can use $HUNCH to draft, boost, or publish approved markets.
• Curation and quality bonds: market creators or curators can bond $HUNCH behind clear, resolvable markets and lose priority when they spam low-quality claims.
• Fee alignment: selected first-party markets can route disclosed fees toward the Hunch treasury, rewards, liquidity, or buyback programs.
• Creator rewards: high-quality market creators, resolvers, and referrers can earn incentives tied to real usage, not vanity engagement.
• Access and status: $HUNCH can unlock creator tools, advanced token-maturity dashboards, API allowances, featured rooms, and reputation surfaces.
• Community governance: token holders can help prioritize market categories, resolver integrations, sponsored rooms, and treasury-backed campaigns.
• Liquidity incentives: $HUNCH can support early liquidity in new first-party markets where the resolution path is clear.

The value unlock is the network effect: more X posts become markets, more markets create fees and proof, more proof builds reputation, and more reputation brings creators and communities back to launch the next market. $HUNCH should sit in that loop as the asset that benefits from PlayHunch becoming the default place where crypto opinions get priced.

Goal: make "tradable from the X post itself" the signature PlayHunch behavior.

1. X post to market card

When a user tags @playhunchxyz on a post, the agent should produce a public reply that feels like an instant market card:

• Extracted claim or token from the parent post.
• Closest existing market, or a new draft market when no good match exists.
• YES/NO price, venue/source, liquidity, deadline, and confidence.
• Two actions: "Take YES" and "Take NO."
• A short reason: why this post could move the market.
• A disclosure line for resolution source and risk.

The first version can use quick links because X does not guarantee true embedded execution everywhere. The product direction should still be X-native: the user starts in the post, sees the trade in the post, and returns to the post with a proof.

2. X-to-quick conversion upgrade

Upgrade /quick/[marketId] into a full X-native landing surface:

• Show the original X post or extracted signal.
• Show the Hunch market card with YES/NO odds, ticket size, and deadline.
• Let the user confirm in one tap after auth.
• Preserve ref=tw_playhunchxyz and the source tweet id for attribution.
• After execution, offer a public proof reply back to the thread.

This turns every agent reply into a tracked acquisition funnel: view -> click -> auth -> deposit -> trade -> proof share.

3. X-native market creation

If no strong market exists, the agent should create a market draft instead of stopping at "no match":

• "Make this market" action for the original poster or tagger.
• Agent-suggested question, outcomes, deadline, resolver, and fee split.
• Market quality score before publishing.
• Creator review screen on PlayHunch.
• Public X reply once the market goes live.

This is the wedge from market discovery into market creation.

4. Proof reply loop

Every filled trade should be shareable as:

• "I backed YES at 42c."
• Receipt link.
• Current odds.
• Agent reason.
• Resolution date.
• Hunch branding.

This proof loop matters because prediction markets grow when the trade becomes social. The user should not need to explain what happened; the card should do the flexing.

Phase 1 milestones

• 40%+ of Twitter-agent replies include two working quick actions.
• 20%+ of X quick-link visitors authenticate or return with an existing wallet.
• 10%+ of authenticated quick-link visitors place a trade.
• Every X-originated trade has a proof page and source attribution.
• No public fallback replies for low-confidence or no-market situations.

Goal: make PlayHunch the best place to trade whether a token is becoming real.

Token markets should move beyond "will price go up." The sharper category is token maturity: measurable markets around whether a token, community, or protocol is graduating from hype into durable activity.

1. Token maturity ladder

Create a maturity model that any token can be measured against:

1. Spark: contract deployed, first liquidity, first holders, first social burst.
2. Liquidity: sustained DEX liquidity, volume, slippage, market-maker depth.
3. Trust: verified socials, website, deployer behavior, audit, locked liquidity, fewer suspicious holder patterns.
4. Retention: holders still present after 7, 14, and 30 days.
5. Utility: product usage, fees, revenue, integrations, governance, ecosystem support.
6. Institution: CEX listing, major wallet support, integrations, index inclusion, or durable treasury behavior.

Each ladder stage can create multiple markets. This is more interesting than pure price because it gives communities a way to trade on legitimacy, not just momentum.

2. Core token maturity market types

Launch these as first-party market templates:

• Market cap milestone: "Will $TOKEN close above $X market cap by date Y?"
• Liquidity milestone: "Will $TOKEN sustain $X DEX liquidity for 72 hours?"
• Holder retention: "Will $TOKEN keep at least N holders 14 days after launch?"
• Volume quality: "Will $TOKEN hit $X organic volume excluding flagged wash wallets?"
• Unlock absorption: "Will $TOKEN stay above $X market cap 72 hours after unlock?"
• CEX listing: "Will $TOKEN be listed on exchange X by date Y?"
• Protocol revenue: "Will protocol fees cross $X in a 7-day window?"
• Buyback/burn: "Will onchain buybacks exceed $X by date Y?"
• Dev activity: "Will the project ship a verified contract/app update by date Y?"
• Social maturity: "Will the project retain N active unique posters for 7 days?"

The key: every template must have a resolver before it has a market.

3. Token maturity page

For any token address or cashtag, Hunch should generate:

• Live market cap, FDV, liquidity, holders, volume, pair data.
• Maturity ladder score.
• Open Hunch markets about the token.
• Related external prediction markets.
• Recent X posts that moved attention.
• Agent risk notes: liquidity, holder concentration, deployer behavior, suspicious trading patterns.
• "Create a market" and "Trade maturity" CTAs.

This becomes the token's prediction layer. A founder can send their community there; a trader can use it as a dashboard; the X bot can link to it in replies.

4. Hunch Market Factory

Generalize the standalone $HUNCH $10M market into a reusable factory:

• Market templates for token metrics, unlocks, launches, governance, revenue, and ecosystem milestones.
• Resolver registry with deterministic data sources.
• Draft -> review -> publish workflow.
• Creator fee split and treasury fee.
• Market status lifecycle: draft, open, closed, resolving, resolved, disputed.
• Resolution evidence page.
• Automated proof cards for winners.

Once this exists, PlayHunch can create markets as fast as X creates narratives.

Phase 2 milestones

• 10 token maturity templates live.
• 25 first-party token markets created.
• 80%+ of first-party markets have automated resolution evidence.
• Token pages convert X traffic better than generic market pages.
• At least one token community treats its Hunch page as the canonical prediction surface for its milestone.

Goal: make users feel like they have a trading desk under every position.

The current agent stack already routes, logs, surveils, and tracks positions. The next stage is to make the portfolio itself feel alive.

1. Position intelligence

Each open position should have:

• Why the user entered.
• Entry odds and current odds.
• Key events since entry.
• Directional impact feed for the user's side.
• Agent confidence trend.
• Exit plan: hold, take profit, cut loss, hedge, or watch.
• Related market opportunities.

This turns the portfolio from a list of bets into a living thesis board.

2. Auto-claim and resolution push

When a market resolves:

• Agent detects resolution.
• Claimable amount is calculated.
• User receives a push.
• Claim is executed or prepared depending on the venue.
• Proof card is generated automatically.

The user should feel rewarded without having to babysit positions.

3. Hedges and correlated-market suggestions

When a user's book gets concentrated, the agent should suggest:

• A hedge market.
• A correlated market with better odds.
• A synthetic position when direct liquidity is missing.
• A "do nothing" recommendation when the hedge is worse than the risk.

This is where Hunch becomes more than a fun swipe product. It becomes a real position companion.

4. Calibration and reputation

Make skill visible:

• Brier/calibration score.
• PnL by category.
• Best markets called.
• Worst misses.
• Public profile for users who opt in.
• Proof-backed leaderboards.

Prediction markets become more social when people can build a reputation for being early and right.

Phase 3 milestones

• 50%+ of users with positions view the portfolio twice.
• 25%+ of resolved winners share proof cards.
• At least 3 agent action types are visible in the portfolio: impact, hedge, exit/claim.
• Calibration score becomes a shareable status object.

Goal: let creators, founders, token communities, and analysts launch markets as their default way to make claims.

1. Creator market pages

Each creator or founder can have a Hunch page:

• Markets they created.
• Markets they traded.
• Accuracy and resolved history.
• Fees earned.
• Current open thesis.
• X-linked proof feed.

This makes market creation reputational. The best creators become distribution partners, not just users.

2. Revenue share

Market creators should earn a transparent share of fees when they bring quality markets and users:

• Creator fee share.
• Hunch treasury share.
• Optional sponsor/bounty contribution.
• Public fee disclosure per market.
• Anti-spam quality gate before markets can earn.

The market factory needs an economic flywheel. Creator fees are the cleanest way to make people bring the internet into Hunch.

3. Community market rooms

For a token, protocol, or ecosystem:

• Open markets.
• Upcoming milestones.
• Token maturity dashboard.
• Creator leaderboard.
• Community PnL and calibration.
• Resolved proofs.
• Agent-generated daily "what changed" brief.

This becomes the prediction-market equivalent of a Discord channel, except every opinion has a price.

4. Sponsored milestone markets

Protocols can fund liquidity or rewards for markets around their roadmap:

• "Will mainnet launch by date Y?"
• "Will TVL pass $X?"
• "Will active wallets cross N?"
• "Will revenue exceed $X?"
• "Will audit be completed by date Y?"

The bullish angle is not fake activity. It is accountable public milestones with transparent resolution.

Phase 4 milestones

• 20 creator pages live.
• 5 token/community market rooms live.
• Creator-created markets drive more volume than internally created markets.
• Sponsored milestone markets become a repeatable GTM motion.

Goal: let other apps, agents, wallets, and communities create and trade Hunch markets without rebuilding the stack.

1. Market creation API

Expose an API for:

• Draft market creation.
• Resolver selection.
• Quote fetch.
• Trade intent.
• Proof fetch.
• Resolution evidence.
• Creator revenue reporting.

The API turns Hunch from an app into market infrastructure.

2. Hunch embeds

Let any website or community page embed:

• A live YES/NO market card.
• A token maturity card.
• A proof card.
• A creator market list.
• A "create this market" button.

Embeds are the web-native version of the X reply loop.

3. Agent market clients

Give AI agents a clean way to interact with Hunch:

• Discover markets related to a topic.
• Create a market draft from a claim.
• Ask for resolver feasibility.
• Place a bounded trade.
• Monitor resolution.
• Retrieve proof.

If agents are going to read the internet and form opinions, Hunch should be the place where those opinions become accountable.

4. Liquidity and settlement layer

Deepen the money side:

• Better routing across venues.
• First-party liquidity for selected markets.
• Market-maker APIs.
• Creator/sponsor-funded liquidity.
• Clear settlement and redemption paths.
• Proof-first accounting.

This is where Hunch becomes durable. Distribution brings users; liquidity keeps them.

Phase 5 milestones

• Public API beta with 3 launch partners.
• 50 embedded market cards live outside PlayHunch.
• Agent-created market drafts become a meaningful share of new markets.
• First-party markets resolve reliably without manual operator work.

Goal: make PlayHunch the default place where crypto opinions get priced.

At scale, PlayHunch should have:

• X-native market cards for every major crypto narrative.
• Token maturity pages for thousands of assets.
• Creator and community market economies.
• Agent-managed portfolios.
• Self-resolving market templates.
• Public proof and reputation graphs.
• APIs and embeds that let the rest of the ecosystem route opinion liquidity through Hunch.

The long-term product is not "a better Polymarket front-end." It is a network where claims become markets, markets become proof, proof becomes reputation, and reputation drives the next wave of liquidity.

Token maturity

Trade whether a token is becoming real:

• Market cap and liquidity milestones.
• Holder retention.
• Unlock absorption.
• Protocol revenue.
• Buybacks and burns.
• Ecosystem integrations.
• CEX listings.
• Mainnet launches.

Launch and pre-launch markets

Trade early project milestones:

• Will token launch by date Y?
• Will the launch clear $X liquidity in the first hour?
• Will the team publish audit/docs before launch?
• Will the token retain N holders after 7 days?
• Will the first 24h volume exceed $X?

Narrative markets

Turn market narratives into tradable indexes:

• AI agents.
• Base ecosystem.
• Arc ecosystem.
• DePIN.
• RWAs.
• Consumer crypto.
• Stablecoin apps.
• Gaming.
• Prediction-market meta.

Founder and protocol execution markets

Make roadmap claims accountable:

• Mainnet by date.
• Feature shipped by date.
• TVL/revenue/users by date.
• Governance vote outcome.
• Audit completed.
• Partnership shipped.

Onchain behavior markets

Use code-resolvable data:

• Whale wallet accumulates or sells.
• Treasury moves funds.
• Liquidity is added or removed.
• Bridge volume crosses threshold.
• Token holder concentration improves.
• Protocol fee revenue crosses threshold.

Social momentum markets

Measure attention without making it the whole product:

• Unique posters over time.
• X follower growth.
• Mentions from verified accounts.
• Community retention after launch week.
• Social-to-market conversion.

1. Hunch Pulse

A daily social-market brief:

• Top X posts turned into markets.
• Top token maturity moves.
• Biggest odds shifts.
• Markets resolving today.
• Best creator calls.
• "Back or fade" CTA for each item.

This can become the daily reason users open PlayHunch even before they trade.

2. Hunch Token Pages

Paste any token address and get:

• Maturity score.
• Open markets.
• Risk flags.
• X catalysts.
• Liquidity/holder/volume data.
• Create-market suggestions.

This should become the default answer when someone asks, "Is this token real?"

3. Hunch Create

A creator-facing market launch flow:

• Paste a claim or X post.
• Agent drafts the market.
• Resolver feasibility score.
• Creator picks deadline and fee split.
• Hunch quality gate approves.
• Market goes live with a share card.

This is the supply engine.

4. Hunch Stack

A richer portfolio:

• Positions.
• Proofs.
• Agent notes.
• Calibration score.
• Realized PnL.
• Watchlist.
• Suggested hedges.

This is the retention engine.

5. Hunch Graph

An opinion graph across users, creators, tokens, and markets:

• Who was early.
• Who was right.
• Which communities predict well.
• Which tokens mature beyond hype.
• Which claims become valuable markets.

This becomes defensibility. The graph is hard to copy once it has proof-backed history.

Keep it simple and compounding:

• Trading fees on first-party markets.
• Builder/referral fees from routed venue trades.
• Creator market fee share.
• Sponsored milestone markets.
• Premium creator/community pages.
• API and embed fees.
• Pro dashboards for founders, analysts, and market makers.
• Treasury/buyback flows from selected first-party markets where disclosed.

The best business model is not ads. It is fee flow from turning attention into markets.

Social Intent Router

Input: X post, token address, cashtag, URL, chart, or user prompt.

Output:

• Existing market match.
• Draft market proposal.
• Token maturity page.
• "No action" when low confidence or unsafe.

This should extend the current Twitter-agent pipeline rather than replace it.

Resolver Registry

A typed registry of data sources:

• Dexscreener.
• DeFiLlama.
• Dune/Subgraph queries.
• Onchain RPC reads.
• CEX listing APIs.
• GitHub activity.
• Governance APIs.
• Protocol-specific adapters.

No resolver, no market.

Market Factory

Generalized from standalone_markets:

• Template.
• Resolver.
• Fee config.
• Creator.
• Status lifecycle.
• Trade ledger.
• Resolution evidence.
• Proof generation.

Proof Engine

Every trade and resolution should produce:

• Stable URL.
• Share image.
• Source tweet/context.
• Receipt data.
• Resolution evidence.
• Claim status.

Quality and Safety Layer

Before a market is public:

• Ambiguity check.
• Resolver check.
• Liquidity check.
• Spam check.
• Prohibited content check.
• Social manipulation check.
• Rate-limit and abuse handling.

Bullish does not mean reckless. Trust is the product.

Next 7 days

• Upgrade X replies into richer market-card replies with YES/NO quick actions.
• Add source tweet attribution to /quick.
• Add post-trade proof share flow for X-originated trades.
• Generalize standalone market types enough to support a second token market.
• Define the token maturity template schema.

Next 30 days

• Launch token maturity pages.
• Ship 10 token maturity market templates.
• Build draft -> review -> publish market factory.
• Add automated resolver registry for Dexscreener and basic onchain reads.
• Launch Hunch Pulse as a daily product/content surface.
• Add creator attribution and fee fields to first-party markets.

Next 90 days

• Let creators launch approved markets.
• Add community/token rooms.
• Launch public proof-backed creator profiles.
• Add Hunch embeds.
• Expand resolver sources beyond Dexscreener.
• Build first Hunch API endpoints for market discovery, proof, and embeds.

Next 6 months

• Make X-native market creation the main acquisition loop.
• Make token pages the main SEO/social destination.
• Make creator markets the main supply engine.
• Make proof-backed reputation the main retention layer.
• Make API/embeds the infrastructure layer.

Acquisition

• X posts processed per day.
• Agent replies with tradable actions.
• X reply click-through rate.
• X-originated wallet sign-ins.
• X-originated trades.

Market supply

• Markets created per week.
• Creator-created share of markets.
• Resolver-backed share of markets.
• Markets with enough liquidity to trade.
• Markets resolved without manual intervention.

Trading

• Weekly transacting users.
• Trades per user.
• USDC volume.
• First-party vs venue-routed volume.
• Repeat trade rate.

Retention

• Portfolio return rate.
• Proof share rate.
• Push open rate.
• Token page revisits.
• Creator page follows.

Trust

• Resolution dispute rate.
• Failed resolver rate.
• Double-fill incidents.
• Public fallback reply incidents.
• Manual operator interventions.

1. Make every high-signal X post tradable.
2. Turn every token into a maturity market page.
3. Let creators launch markets from claims.
4. Resolve crypto-data markets by code.
5. Make every trade and resolution shareable proof.
6. Build reputation around who was early and right.
7. Open APIs and embeds so Hunch becomes prediction infrastructure.

If PlayHunch executes this, it does not have to compete as "another prediction market app." It becomes the layer that turns social conviction into priced, settled, proof-backed markets.