HedgeKit

AI-powered risk copilot for prediction markets that finds hedges, explains tradeoffs, and shows payoff protection before you trade.

Comment

Inspiration

Prediction markets are incredibly good at pricing event risk, but the tooling around them is still built mostly for speculation, not risk management. I thought that was a huge missed opportunity.

If someone is exposed to tariffs, elections, recession risk, or a concentrated prediction market position, they should be able to describe that exposure in plain English and immediately understand what contracts could offset it, why those contracts make sense, and how much protection they provide.

That was the inspiration for HedgeKit: turning prediction markets from trading dashboards into an AI-powered hedging system for real-world event exposure.

What it does

HedgeKit is an AI-powered risk copilot for prediction market hedging.

A user can start with either:

  • a prediction market position they already hold, or
  • a real-world exposure like tariffs, macro shocks, election risk, or crypto drawdowns.

From there, HedgeKit:

  • interprets the exposure
  • runs an AI hedge committee to evaluate hedge ideas
  • searches across markets and platforms for relevant contracts
  • explains why each hedge works
  • surfaces confidence and tradeoffs
  • shows before-and-after payoff impact
  • lets the user launch the hedge in one click

It also includes portfolio and market intelligence views so users can understand broader exposure, compare opportunities across venues, and move from analysis to action in one workflow.

How I built it

I built HedgeKit as a full-stack web app using:

  • Next.js 16 with the App Router
  • React and TypeScript
  • Supabase for persistence and saga state tracking
  • OpenAI via the OpenAI SDK for the AI hedge pipeline
  • Polymarket and Kalshi market data integrations
  • CoinGecko for crypto price context
  • Recharts for payoff visualization

The technical core of the project is the AI hedge committee.

Instead of relying on a single prompt, I built a structured multi-stage system:

  • a risk parser agent to understand the user’s exposure
  • a market search agent to identify relevant contracts
  • a constructor agent to propose hedge ideas
  • and a skeptic/reviewer stage to challenge weak or low-confidence recommendations

I also added:

  • structured output validation
  • fallback logic
  • heuristic retries
  • confidence scoring
  • grouped hedge recommendations
  • curated demo paths for reliability during the hackathon

On the execution side, I built a saga-based multi-leg execution engine. That gives HedgeKit a real one-click hedge flow: it creates the set of hedge legs, tracks execution state, applies spending-cap rules, and supports rollback behavior if a leg fails.

So HedgeKit is not just a UI on top of an LLM. It is a connected system combining:

  • an AI hedge committee
  • a payoff and confidence engine
  • and a one-click execution workflow

Challenges I ran into

The hardest challenge was making the AI feel trustworthy, not just impressive.

It is easy to generate finance-sounding suggestions. It is much harder to build a system that can explain:

  • why a contract is actually a hedge
  • what risk it protects against
  • how confident the system is
  • and what happens when the answer is weak or uncertain

That is why I moved away from a single-prompt approach and built the hedge committee architecture.

Another challenge was cross-platform normalization. Different markets have different APIs, liquidity, and execution realities, so I had to unify them into one product experience while still being honest about what is real and what is simulated.

Finally, the one-click experience was much more technical than it looks. It required multi-leg execution logic, persistent state management, spending-cap safeguards, and rollback handling so it behaved like a real trading workflow instead of just a demo button.

Accomplishments that I'm proud of

I’m proud that HedgeKit is not just “AI that suggests trades.”

I built:

  • a real AI hedge committee instead of a single chatbot prompt
  • structured hedge reasoning with confidence and skeptic review
  • cross-platform contract discovery
  • payoff visualization that makes downside protection understandable
  • a portfolio-level risk entry point
  • and a one-click multi-leg execution flow backed by saga logic and rollback behavior

I’m also proud that the product became much more ambitious during the build. It started closer to a market intelligence tool, but evolved into something more compelling: a system that helps users turn real-world event exposure into actionable prediction-market hedges.

What I learned

I learned that the most important part of an AI finance product is not generation. It is trust.

Users do not just want interesting outputs. They want to know:

  • why the system chose this hedge
  • what assumptions it is making
  • where confidence comes from
  • and whether the recommendation is actually actionable

I also learned that multi-agent structure matters. Breaking the problem into parser, search, constructor, and skeptic stages produced much stronger results than trying to do everything in one shot.

And I learned that AI becomes much more compelling when it is connected all the way to action. That is why the one-click hedge flow ended up being just as important as the recommendation engine itself.

What's next for HedgeKit

After the hackathon, the next step is turning HedgeKit from a strong prototype into a production-grade platform.

The biggest priorities are:

  • real user authentication and wallet/account linking
  • fully live cross-platform execution
  • stronger historical confidence calibration
  • richer portfolio-level exposure analysis
  • and broader coverage of real-world risk scenarios

On the AI side, the next step is making the hedge committee much more powerful:

  • having the agents communicate with each other more deeply instead of acting as mostly sequential stages
  • letting them learn from mistakes and weak recommendations over time
  • and giving them memory of each user’s past hedges, preferences, and trading behavior so the system becomes more personalized

Long term, I want HedgeKit to become the default interface for using prediction markets as a hedge layer, not just for traders, but for anyone exposed to event-driven risk.

Built With

Share this project:

Updates