Poly Predictor Kit

Developed the Gemini-powered market summarization and TF-IDF / Logistic Regression comment-classification pipelines as part of the team project that won the Polymarket Track at QuackHacks 2025.

The team's architecture

Poly Predictor Kit is a team project. These parts are credited to the team:

• The Chrome extension and its popup, which call all three services.
• The Flask service that wraps the summarizer for the extension.
• The steamroller detector, the risk rule explained under The risk shape.
• A web front page, not connected to the services.

Devpost listsUmar Turdumambetov · Bekzat Uraimov · Shamil Khamrayev · Akan Abdireshov · Zhanbolot Eraliev · Raimbek Alish

Team from Devpost, read on 2026-10-24 Public record

Open any Polymarket event, open the extension, and choose one of three buttons. Each calls its own Python service on the same machine and shows the answer as text.

1. The numbers

   “Poly AI Summarizer”

   The event's markets and prices become a structured prompt; Gemini writes a short, hedged summary of what they imply.

   What comes back3–6 sentences of plain text: what current prices imply, one or two risks that could change the odds, both sides of the view, and a reminder that it is not financial advice.

   Raimbek's pipeline

2. The conversation

   “Emotional Damage Predictor”

   Every comment on the event is labeled by a saved scikit-learn model; the result is the share of emotional against rational comments.

   Its message, as the code writes itFrom comments provided it seems like the event might be based on Emotions: N%

   Raimbek's pipeline

3. The numbers

   “Steamroller Check”

   A rule, not a model: flags an outcome whose price leaves a tiny upside and a huge downside.

   Its message, as the code writes itSIDE looks like a steamroller trade. Current implied probability is about P%. At this price, one loss wipes roughly N average wins. There are about D days left until resolution.

   Team component

Button names and message formats from popup.html and the services Verified in code

The market summarization pipeline: the module that finds a Polymarket event through the Gamma API, turns its markets into a structured prompt and asks Gemini for a short insight.

1. Find the event

   It accepts what a person would paste: an event's address, its slug, a numeric id or a search phrase. Each goes to the Gamma API through /events/slug/…, /events/… or /public-search.

2. Keep what matters

   Up to three of the event's markets, open ones first, with their questions, status, volume and outcome prices.

3. Read prices as probabilities

   The Gamma API returns outcomes and prices as JSON strings. The module parses them and writes each price beside its implied percentage.

   In the API response

   outcomes: '["Yes","No"]'outcomePrices: '["0.54","0.46"]'

   →

   In the prompt

   Outcomes: Yes: 0.54 (~54.0%); No: 0.46 (~46.0%)

4. Ask with rules

   The prompt carries the event's title, status, end date and volume, then each market. It asks Gemini (gemini-2.5-flash, through the public REST API, with the key read from the environment) for 3–6 sentences under explicit rules:

   The prompt's instructions and rules, verbatim

   406Using this information, write a short AI Trade Insight section in 3–6 sentences.
   407
   408Focus on:
   409- What current prices roughly imply about market expectations.
   410- 1–2 key scenarios or risk factors that could change the odds.
   411- A balanced view that mentions both upside and downside perspectives.
   412
   413Rules:
   414- Do NOT give explicit instructions like "you should buy" or "sell now".
   415- Do NOT mention specific position sizes.
   416- Explicitly remind the reader that this is NOT financial advice.
   

The module began as a command-line tool (commit 5f34cdf); the team then wrapped it in the Flask service that the extension calls, with the key loaded from a .env file.

Raimbek developed the comment-classification pipeline. Its two halves run at different times, and only the first uses Gemini.

The three labels Verified in code

Gemini labels comments with these definitions, verbatim from its prompt. The trained model learns the same three classes.

EMOTIONAL

emotion-heavy, opinions, little/no reasoning.

RATIONAL

uses reasoning, facts, or structure to support claims.

SPAM

off-topic, self-promo, nonsense, low-effort, "gm", etc.

The model

A scikit-learn pipeline: TF-IDF features from the comment text, then logistic regression. It trains on an 80/20 split that keeps the labels' proportions and prints a classification report. No scores are published, so none are claimed here.

48    model = Pipeline([
49        ("tfidf", TfidfVectorizer()),
50        ("clf", LogisticRegression(max_iter=1000)),
51    ])

Snowflake stores; scikit-learn trains. The labeled comments are appended to a Snowflake table through Snowpark and read back into pandas, and the model is fitted locally. The README's “Snowpark ML training” is not what the code does.

After each analysis, the runtime service appends its own labels to that table and retrains, so later training data includes the model's own labels, not only Gemini's.

The third button flags a “steamroller”: an outcome priced so high that winning pays little and losing costs nearly everything. It is arithmetic on the price, and part of the team's architecture.

An explanation, not a trading tool. The calculator below evaluates the team's rule for a price you choose. It uses no market data and recommends nothing.

Not claimed Not claimed

• Model accuracy. The training script prints a report, but no scores are published.
• Trading results, recommendations or advice. Nothing on this page trades or recommends; the summary's own prompt rules out buy or sell instructions.
• A deployment. The services run locally on ports 5000–5002.
• Running or sharing the trained classifier. This page explains it; it does not run it.

The team recorded a demo of the working extension: watch it on YouTube