How to Give an AI Agent Market Data

The mistake almost everyone makes first is pasting a screenshot of a chart and asking the model what it sees. That forces it to recover prices from pixels — and it will confidently give you numbers that are close, plausible and wrong. Here are the four real options, compared on what they cost in tokens and what each one quietly breaks.

The four options

1. Screenshots — the intuitive wrong answer

It feels natural: you look at a chart, so show the model the chart. Vision models genuinely can describe structure, spot obvious patterns and comment on trend direction.

What they cannot do is read prices accurately. The model is inferring numeric values from rendered pixels against an axis it also has to infer. Ask "what was the high on 3 March" and you will get an answer that looks right and is not — and crucially, the model has no way to know it is wrong, so it will not hedge.

Use screenshots for qualitative questions about shape. Never for anything you intend to calculate with.

2. Pasting CSV — exact but expensive

Exact prices, no tooling, works with any model. For a small window — a hundred bars around an event — this is often the right answer, and its simplicity is genuinely worth something.

It stops working at scale, for three reasons that compound:

• Token cost. ~89,000 tokens per year of hourly data on one instrument, as derived above. Multiply by instruments and timeframes and you exhaust the budget before the analysis begins.
• No aggregation. Asking "which hour is most volatile" means the model must hold every bar and compute across them. Models are poor at arithmetic over thousands of rows, and confident about the results.
• Attention dilution. The relevant twenty bars are buried among six thousand, and reasoning quality degrades accordingly.

Rule of thumb: paste CSV when the answer depends on specific bars you can identify in advance. Do not paste CSV when the answer depends on a statistic across many bars.

3. REST API — exact, but the agent does the work

The agent fetches only what it needs, so token cost is proportional to the answer rather than the archive. This is a real improvement over pasting.

The friction is that the agent must write the code: authenticate, construct the request, handle pagination, parse the response, then aggregate. Every one of those is a place to go wrong silently, and the agent will not always tell you that its aggregation was subtly incorrect.

Rate limits are the other constraint, and they are tighter than people expect. Alpha Vantage's free tier permits 25 requests per day — enough for a handful of queries, nowhere near enough to explore a dataset. An agent that needs twenty queries to answer one question exhausts that in an afternoon.

4. MCP — the server does the aggregation

The relevant difference is not the protocol. It is that computation happens server-side, so the agent receives an answer rather than the raw material for one.

"Which trading hour is most volatile on EURUSD" over five years touches 1.9 million bars. As CSV that is millions of tokens. Over MCP the server scans them and returns a 24-row summary — a few hundred tokens — and the numbers are computed in code rather than estimated by a language model.

The FXAbsolute MCP server exposes 28,412,683 one-minute bars across 15 instruments with no API key and no request cap, through tools including:

Install is a sparse clone — 806 KB, not the whole repository, because the server fetches candle data over HTTPS and caches it locally:

git clone --depth 1 --filter=blob:none --sparse https://github.com/varsansri/fxabsolute
cd fxabsolute && git sparse-checkout set mcp
cd mcp && npm install

claude mcp add fxabsolute -- node "$PWD/src/index.js"

Verified on 17 August 2026: a fresh clone of that form is 806 KB, and the full tool smoke suite passes against live data in 13.4 seconds.

Choosing

The underlying principle across all four rows: let the model reason and let code count. Language models are excellent at deciding which statistic matters and poor at computing it across thousands of rows. Any method that pushes the counting into code and the judgement into the model beats one that inverts them.

And for the qualitative half, a human still needs screen time. FXAbsolute replays the same archive bar by bar in a browser, free, no account — the agent queries the numbers, you practise the reading.

The shortest working route, end to end

If the goal is simply "my agent should be able to look up real prices", this is the whole of it:

claude mcp add fxabsolute -- npx -y fxabsolute-mcp

That installs a published npm package (fxabsolute-mcp) which is also listed in the official MCP Registry as io.github.varsansri/fxabsolute. No key, no account, no rate limit.

What the agent gains is not "knowledge of markets" — it is the ability to compute over 28.4 million bars instead of recalling an impression of them. The difference shows up immediately in falsifiability: a screenshot forces the model to read prices out of pixels, and a pasted CSV caps you at whatever fits the context window. A tool call has neither limit, because the aggregation happens before the model sees a number. Asking about 1.4 million bars costs the same handful of tokens as asking about a hundred.

The honest caveat, which any data source you choose should give you: this archive carries no volume — the on-disk record is a timestamp plus four float32 OHLC values, and no tool invents a proxy for it.

Frequently asked questions