What a Windmill agent can read, and how often it runs
Last updated: October 8, 2026
A Windmill agent is a language model with a fixed set of tools. On each run it reads Kalshi's markets, its own account and the public web, then decides whether to trade. This page lists exactly what those tools reach, what they do not, and when runs happen.
The tools
Every agent has the same tools, on paper and live. Besides the reads below, it can place and cancel limit orders and record its reasoning. Each run's transcript shows every tool it called, with what it sent and what came back.
| Tool | What it reads | Limit |
|---|---|---|
| search_markets | Kalshi events matching a plain-English description, with their strikes' bid, ask, last price and volume, and matching series | 10 events, 12 strikes each |
| get_markets | One series' open events, one event's full ladder, or the whole venue filtered by category, frequency or closing time | 20 events; 40 strikes of one event |
| get_market | One market: title, status, prices, close time, price grid, fee settings and, once settled, the result | one market |
| get_orderbook | The resting bids and asks of one market | 10 price levels a side |
| get_price_history | One market's last trade price and volume per minute, hour or day | 120 periods |
| get_portfolio | The agent's own cash, positions with their value, and resting orders | all of them |
| web_search | A short answer to a question, with its sources and their dates | 12 a run |
| fetch_url | The body of a public https URL: JSON, text, or a page's text | 12 URLs a run |
Kalshi: markets, order books and price history
An agent can find any open Kalshi market: by describing it in words (“NYC high temperature tomorrow”, “bitcoin price in 15 minutes”), by listing a recurring series such as an NFL spread or a daily weather market, or by filtering the whole venue by category (politics, economics, crypto, sports, climate and weather and the rest of Kalshi's own categories), by how often a series repeats, or by how soon its events close. If you limit an agent to certain series, events or markets, its searches show only those.
For one market it can read the current bid, ask and last price, the close time, the price grid, the fee settings and, once it settles, the result; the order book, up to 10 price levels on each side; and the price history.
How far back the price history goes
Price history is the market's own trading: the last trade price and the volume in each period, at a resolution of a minute, an hour or a day, up to 120 periods per call. That is the last two hours by the minute, the last five days by the hour, or about four months by the day. Periods with no trades are left out. It never goes back further than the market itself, and many Kalshi markets live an hour or a day, so for those it holds hours of data, not months. History of the thing a market is about, such as bitcoin's price or past temperatures, comes from the web.
Its own account
An agent reads its own cash, the cash set aside behind its resting buys, its positions with their average cost and current value, its realized profit and loss, and its resting orders. A paper agent reads its paper account; a live agent reads its own orders and positions on your Kalshi account, and is told when your Kalshi balance is lower than the cash the agent has to spend. It sees only its own positions and orders, not your other agents'.
The web: search and any public URL
web_search asks a search model a question and returns a short answer with its sources and their dates, which can be limited to the last day, week, month or year. It suits news and recent events. The answer is cut at about 1,200 characters, a run may make 12 searches, and asking the same question twice in a run costs nothing.
fetch_url reads any public https URL and returns what it says: JSON as compact JSON, a web page as its text. From a large JSON document it can keep only the path and fields it needs. This is how an agent gets live numbers about the world. Sources Windmill's own test agents read:
- National Weather Service observations, forecasts and climate reports (api.weather.gov)
- MLB's live game feed (statsapi.mlb.com)
- AAA's average gas prices by state (gasprices.aaa.com)
- ERCOT's supply and demand dashboard (ercot.com)
- Chart and ratings sites such as kworb.net and televisionstats.com
For crypto markets the builder points agents at Coinbase's public candles:api.exchange.coinbase.com/products/BTC-USD/candles?granularity=3600 gives hourly bitcoin prices.
What an agent cannot read
- Streams. No websockets and no streaming feeds, from Kalshi or anyone else. Each read is a single request at the moment of the call.
- Private or paid data. Nothing behind a login or an API key, and no data you upload: fetch_url sends no credentials.
- Pages built by JavaScript. fetch_url reads what the server sends and runs no scripts, so numbers a page draws in the browser are not there.
- Your own code or models. An agent runs no code. It reasons over what the tools return.
- Its past runs in full. Between runs it keeps only its account and its last report (see below).
The builder, the chat that makes agents, reads the same markets and web with the same tools, and says so when a strategy needs data a run cannot get.
How often it runs, and what a run is
An agent does not watch the market. It runs on a schedule: an interval such as every 30 minutes or every 2 hours, or a cron expression in UTC for set times of day. The shortest schedule allowed is every 10 minutes; one that fires more often is rejected. You can also start a run by hand. Runs count against your plan's run budget, which the pricing page lists.
A run is a short loop. The model starts from a snapshot of its account and the report it wrote at the end of its last run, then calls tools, reads what comes back and calls more, one step at a time, until it has decided. Each market or web read is live at the moment of the call. A run takes at most 12 steps unless you set another cap (20 at most), and stops after 10 minutes. It ends with a report of at most 2,000 characters, the only memory passed to the next run.
Kalshi's recurring markets roll over on the quarter-hour: the 15-minute ones at :00, :15, :30 and :45, the hourly ones on the hour. For 20 to 40 seconds after that, a series shows no open market, so schedules stay off those minutes. An interval that would land on one fires 2 minutes later, and the builder moves a cron schedule the same way, to 2, 17, 32 and 47 past the hour.
What code enforces and what the model decides
The model decides which markets to read, what the data says, and whether, what and how much to trade. Code decides what it is allowed to do: every order passes the agent's limits first (its allocation, the largest order, the markets it may enter, and the optional limits on closing time, crossing the spread, new orders per run and live buys per day), and an order that breaks one is refused with the rule it broke. A stop loss, if you set one, pauses the agent before a run. The AI trading bot page explains each limit.
None of this makes a strategy profitable. Reading more data is not an edge by itself: in our own test of about 90 strategies on paper, none found an edge that held up. Read the results.
Questions
- Can it run my own model on market data?
- No. An agent is a language model calling the tools on this page; it cannot run your code, load a model you trained, or hold a live feed open. It can do what you describe in words with the numbers it reads, such as comparing a price with a moving average it works out from fetched candles. If your model publishes its output at a public https address, the agent can read that output on each run, but anyone else can read it there too.
- Can I bring my own data source?
- Yes, if it is a public https URL that answers a plain GET without logging in: name it in the strategy, or ask the builder to find one. JSON APIs work best, because the agent can pick out the fields it needs. Pages that need an API key, a login, a POST or JavaScript to show their numbers will not work.
- Can it react to a price move within seconds?
- No. It runs on a schedule, every 10 minutes at the most, and each run reads the market as it is at that moment. Strategies that need to react within seconds or minutes are a poor fit.
- Does it remember earlier runs?
- Only through what it can read again: its cash, positions and resting orders, and the short report it wrote at the end of its last completed run, which is passed to the next one.
- Is it the same on paper and live?
- Yes. A paper agent and a live agent have the same tools and read the same Kalshi markets; the account they read and trade is the paper book or your Kalshi account. How paper trading works.
- Which models run the agents, and how many runs do I get?
- Both depend on your plan and change from time to time, so the pricing page lists them.