AI Agent Development

# Upwork Job Post — Sports Betting Data, MCP Server & AI Agent Engineer --- ## SHORT VERSION (for the search-result hook / TL;DR) Looking for an experienced backend engineer to build a real-time sports betting data pipeline with AI agents on top. You'll scrape and integrate odds/pricing from ~30 sportsbooks (API feeds plus logged-in browser automation), normalise it into one database, expose it through an MCP server, and build autonomous agents (OpenClaw) that analyse pricing, generate recommendations, and push markets into our platform via API — one workflow with a human-approval gate, one with a low-latency automated repricing loop. Strong Python (async), web-scraping/anti-bot (Playwright), REST/websocket integration, Postgres, and VPS deployment (Docker/systemd) are a must. MCP server experience and LLM agent orchestration (tool-calling, scheduled autonomous workflows) are core to this role. Sports betting/odds domain knowledge (OpticOdds, OddsJam, Fundist) a big plus. Secure credential handling and strong written English essential. Start your proposal with "BOOST". --- # LONG VERSION (full job description) ## Overview We operate an online sportsbook and are building an internal **odds-intelligence and automation platform**. The system continuously monitors pricing and promotions across roughly 30 competitor sportsbooks, analyses that data against a sharp reference feed, and uses AI agents to generate priced markets that are published into our own back-office platform — some through a human-approval workflow, some through a fast automated loop. This is not a throwaway scraper. It is a production system with real money and real liability attached to its outputs, so reliability, correctness, observability, and security are non-negotiable. The architecture is already designed — flowcharts, a component diagram, MCP tool specifications, a phased build plan and a data model exist and will be shared with the selected candidate. We know what we want built; we need a strong engineer to execute it cleanly and own it through to production. You will be building three things that fit together: 1. A **data pipeline** that collects, normalises and stores competitor odds and promotional pricing. 2. An **MCP (Model Context Protocol) server** that exposes that data and a set of controlled actions as tools. 3. A set of **AI agents** (built on OpenClaw) that consume those tools to analyse pricing, produce recommendations, route them through approval, and publish markets — on a schedule and in real time. ## The problem we're solving Sportsbooks constantly adjust prices and run promotional "boosts". Tracking what competitors are doing by hand is slow and incomplete, and reacting to fast-moving pricing situations manually is impossible at scale. We want a system that watches the whole market for us, tells our traders where the opportunities are with a clear recommendation and a confidence rating, and — within limits we set — acts on the safe ones automatically. Every output must be measurable so the system learns which decisions actually worked. ## What you'll build — in detail ### 1. Collection layer - A single, well-defined **adapter interface** so each sportsbook is a pluggable module producing the same normalised output. - **~30 book adapters** delivered in waves. First wave: 5 books spanning very different frontends (to prove the framework), then the rest in batches. - Two collection modes: **API feeds** where a commercial data provider (e.g. OpticOdds) covers a book, and **browser automation** (Playwright or similar) for logged-in scraping where no feed exists. - Robust handling of logins, session persistence, rate limiting, geo/proxy routing, and anti-bot measures — run at human pace, resilient to layout changes, with clear alerting when an adapter breaks. - **Credentials and secrets handled entirely server-side.** They must never appear in prompts, logs, transcripts or the repo. ### 2. Normalisation, taxonomy and storage - Map every scraped market/boost into a shared schema and a market taxonomy (match result, totals/goals, player props, same-game multis, longshots, etc.). - **Dedupe identical markets across books** — this powers a "consensus" view (how many books offer a market and at what price range). - Decimal odds throughout; a clean, queryable database (Postgres preferred, SQLite acceptable for early phases). ### 3. Reference-price integration - Integrate a **sharp reference feed** (Pinnacle directly, or via OpticOdds/OddsJam) and compute **de-margined fair prices**. - Where the reference feed doesn't cover a market (e.g. some player props), fall back to a de-margined multi-book consensus, and flag which method was used so downstream confidence scoring can account for it. ### 4. MCP server - Build an **MCP server** exposing the data and actions as tools, for example: `get_boosts`, `get_consensus`, `get_fair_price`, `propose_boost`, `publish_boost` (permission/token-gated), `get_performance`, `find_arbs`, `get_our_exposure`, `reprice_market`. - This is the single integration surface: it holds all credentials and API keys, and every agent or client talks to the system only through these tools. Clean schemas, validation, auth, and audit logging on every call. - `publish_boost` and `reprice_market` are side-effectful and must be strictly gated — publishing must be impossible without a valid approval token or being inside a pre-set risk envelope. ### 5. AI agents (OpenClaw) — core to this role We want autonomous agents built on **OpenClaw** (an open-source agent gateway) that use the MCP tools to do real work. There are two agents in the initial scope: **Agent A — Boost/pricing agent (scheduled, human-in-the-loop).** - Runs on a schedule (e.g. nightly). Pulls upcoming fixtures, competitor boosts and fair prices via MCP tools. - Generates a set of recommended priced markets per fixture, each with: a **confidence score**, a **market-consensus comparison** (how many books offer it and at what price), a **purpose tag** (acquisition / retention / engagement), and a **suggested max stake** derived from confidence and expected liability rather than a fixed value. - Delivers recommendations as **approval cards to Telegram**, where a trader approves / edits / rejects. Only approved items are published to our back office. Rejections and edits are captured as feedback. **Agent B — Arbitrage/risk agent (real-time, envelope-bounded).** - Continuously scans for arbitrage/pricing-discrepancy situations across the tracked books against the reference feed. - Operates two modes: a **defensive mode** that instantly suspends or reprices our own markets when they become the outlier (protecting the book), and an **opportunity mode** that, strictly within a **risk envelope the trader sets** (market whitelist, price floor vs fair, liability caps), acts automatically — because these situations live for minutes, not hours, and cannot wait for manual approval. - Includes customer-risk controls: IP scoring, duplicate-account/multi-accounting detection, and fast limiting triggers; plus configurable void/compensation handling. Both agents must be observable (every decision logged), safe (hard caps, kill switches, dry-run modes), and controllable by non-engineers through the parameters/envelopes they set — not by editing code. ### 6. Publisher (back-office integration) - Integrate with our back-office platform, **Fundist**, via its API to create and reprice markets (a manual will be provided). - **Dry-run mode first**: the publisher prints the exact payload for human execution until verified. Then live publishing with **post-publish verification** (re-read the market and confirm price/stake/terms match; alert on mismatch). - **Benchmark and document Fundist's true repricing latency early** — this determines how aggressive the real-time agent's envelope can safely be. ### 7. Settlement & learning loop - Nightly pull of settlement data per published market (claims, staked, hold/cost, new-vs-existing customer split, deposits within 24h). - Store performance by archetype (sport × market type × purpose × price band) so confidence scoring and stake sizing improve over time, and so we can see what has actually worked. ### 8. Infrastructure, deployment & ops - Deploy on a VPS (Docker, systemd), with the OpenClaw Gateway running continuously. - Scheduling (cron-style), a queue where appropriate, monitoring, and **failure alerting to Telegram** (including adapter-breakage alerts). - Backups of state/DB, secret management, and sensible hardening (loopback/tailnet-bound services, dedicated tokens). ## Must-have skills - **Python (async)** — strong, production-grade. - **Web scraping / browser automation** at scale, including **logged-in sessions and anti-bot handling** (Playwright, Puppeteer, or equivalent). - **REST and websocket API integration**; comfortable with real-time / low-latency data. - **Postgres**, schema design, dedupe/normalisation of messy real-world data. - **Scheduling / queues / background workers.** - **VPS deployment** — Docker, systemd, monitoring, alerting. - **Secure credential and secret handling.** - Strong **written English** and disciplined **Git** workflow. ## Core to this role (please address explicitly in your proposal) - **MCP (Model Context Protocol) server** design and implementation. - **LLM agent orchestration** — tool-calling agents, scheduled autonomous workflows, guardrails, human-in-the-loop approval patterns, and safe automated actions with hard limits. Experience with **OpenClaw** specifically is a strong plus; general agent-framework experience (LangGraph, custom tool-calling loops, etc.) is relevant. ## Nice to have - Sports betting / trading domain knowledge — odds formats, bookmaker margins, arbitrage, same-game multis, liability/risk management. - Experience with **OpticOdds / OddsJam** or similar betting data feeds. - Experience with **Fundist** or a comparable sportsbook back-office/iGaming platform. - Telegram bot development (inline approval flows). ## How we'll work - **Milestone-based, starting with a paid MVP** so we both de-risk before committing to the full build. MVP milestone: the collection framework + 5 book adapters + the reference feed + a consensus output (this is a working checkpoint, useful on its own). - Then milestones through the remaining phases: full adapter set, MCP server, Agent A with approval flow, publisher (dry-run then live), Agent B, and the settlement/learning loop. - Estimated total scope: **~8–16 developer-weeks** depending on final adapter count, with an **ongoing maintenance retainer** available for the right person (adapters need upkeep as books change). - Architecture docs, tool specs and diagrams are ready to hand over. You'll get direct access to us for questions — we're technical and responsive. ## To apply, please tell us 1. A **data pipeline or scraping system you shipped to production** — how it was architected, what broke over time, and how you handled reliability. 2. Your experience with **logged-in scraping at scale** and defeating/coexisting with anti-bot measures. 3. Whether you've **built an MCP server and/or LLM agents** — describe the project, the tools/guardrails, and share a link or repo if you can. 4. Any **betting/odds/iGaming** experience. 5. Your **availability** (hours/week) and your **rate**. 6. **Start your proposal with the word "BOOST"** so we know you read this in full. We're looking for someone who can own this end to end, cares about doing it properly, and communicates clearly. If that's you, we'd love to talk. ---