Research · first study
I gave a frontier agent a guide to my local tool. It used more model work, not less.
I expected that an AI agent, handed Tables and a short guide to using it, would turn a picture of a table into a CSV with less model work than reading the picture itself. On seven small tables it did not.
Run on 19 September 2026.
One thing to keep in mind. There is no agent skill or guide to install. This was a test of my own idea, on seven small tables I had made myself. It says nothing about Tables used by a person who checks the result.
What I tried
I asked Claude Code for a CSV of one table image, three ways:
- Normal. The request alone, with the agent’s usual tools.
- One-line instruction. The same request plus “Complete the task with as little model work as practical.”
- Guide and Tables. The same request plus my guide and a working copy of the Tables reader.
Seven images, once each way.
What happened
With the guide and Tables, the agent did more work. Across the seven tables it wrote 6,192 output tokens against 3,743 without the guide, took 148 seconds against 89, and got one fewer table exactly right. The cheapest of the three was the one-line instruction, at 2,791 output tokens with every table right.
Without the guide, the agent looked at the picture and wrote the file. With it, the agent ran my reader, copied out its rows and reported an unreviewed draft, as the guide told it to. Six of the seven times it never opened the image.
The one table it got wrong is the reader’s known mistake: an extra empty row on a table without ruling lines, shown on the Tables page. The agent kept the row, as the guide requires, and told the person to check it.
Why I think it went that way
For a twelve-cell table, reading the picture costs the model very little. The guide adds its own text, the reader’s output and a longer report, and those cost more than the reading they replace. That may change on much larger tables. I did not test it.
Every session also carried about 70,000 tokens of Claude Code’s own fixed context before any work on the table. The differences between the three ways are small beside that.
What one table costs an agent
The run without the guide is also a record of what asking a frontier agent costs for this job: three model turns, about 535 output tokens and about 13 seconds for each table. Running my reader directly needs none of that, keeps the picture on the computer, and gave the same cells: 125 of 125, and 6 of 7 whole tables.
The wording this supports: no remote inference was required for these tested executions, at the same cell exactness. That is a token budget for this task, roughly what one small table costs if the alternative is asking Claude Code. It is not a reduction anyone made, because nobody was seen using an agent for this beforehand.
What I do now
I have retired the claim that Tables and this guide reduce an agent’s model work on small clean tables. The guide stays as documentation of the reader’s command-line use. Tables remains a tool for a person who checks the result.
If I take this further, the one next question is whether the comparison changes on larger tables that were not used in development. That has not been started.
What this does not tell you
- Anything about tables that are large, dense, unfamiliar or real. All seven were examples the reader was built against.
- Whether another agent or model, or a shorter guide, would do better.
- How much the result varies. There was one pass.
- Anything about energy. I did not measure it.
The detail
Everything behind the account above, for anyone who wants to check it.
The numbers
| What was counted | Normal | One-line instruction | Guide and Tables |
|---|---|---|---|
| Whole tables exact, of 7 | 7 | 7 | 6 |
| Exact cells, of 125 | 125 | 125 | 125, plus one extra empty row |
| Sessions that failed or retried | 0 | 0 | 0 |
| Model turns | 21 | 21 | 22 |
| Output tokens | 3,743 | 2,791 | 6,192 |
| Uncached input tokens | 42 | 42 | 44 |
| Cache-write input tokens | 87,542 | 87,238 | 96,085 |
| Cache-read input tokens | 412,857 | 413,018 | 453,152 |
| Session time | 88.8 s | 77.8 s | 148.2 s |
| Local reader time and peak memory | not used | not used | about 1.0 to 1.3 s and 500 to 556 MB per image |
| What was counted | Normal agent: range (mean) | Tables reader run directly |
|---|---|---|
| Remote model requests | 3 turns | none |
| Output tokens | 328 to 1,304 (mean 535) | none |
| Cache-write input tokens | 11,950 to 13,974 (mean 12,506) | none |
| Cache-read input tokens | 58,487 to 59,903 (mean 58,980) | none |
| Time | 10.1 to 20.1 s (mean 12.7 s) | about 1.0 to 1.3 s, 3.4 s on the first call |
| Local peak memory, reader process | not observed | 500 to 556 MB |
| Image sent off the computer | yes | no |
Limits on the token budget:
- It is demand that could be avoided, not a reduction anyone made. Nobody was observed using an agent for this task beforehand. If the alternative is typing the table by hand, there were no tokens to begin with.
- Nearly all the input tokens are Claude Code’s fixed context, not work on the table. They describe this agent and this configuration. A bare model call with one image was not measured and would be far smaller.
- The one-line instruction lowered the agent’s own figure, to a mean of 399 output tokens per table.
- The local route is not free. It needs a 366 MB runtime set up once, and about a second of local processing for each table.
- Coverage differs on real inputs. The reader refused three of my twelve real tables, so a budget counted only on tables it can read would overstate the benefit.
- Tokens are model demand, not energy.
How the test was set up
- Agent: Claude Code 2.1.278 in headless mode with the model claude-fable-5-1, on an Apple M1 Pro with 32 GB of memory and macOS 27.0.
- Inputs: seven invented table images, five rendered and two photographed, fixed before the pass. My own tables were not used.
- One fresh session for each image in each of three arms, 21 sessions in total. Every arm had the same tools: a shell and local files, with web tools and connected services off.
- Each session ran in a new folder outside the repository holding only the image under a neutral name. The guide arm had a minimal copy of Tables with no test files, expected answers or other documents.
- Each saved CSV was compared with answers written before any run, for whole-table equality and for exact cells. No person reviewed any output.
Everything that was not measured
- Energy use, or any reduction in it.
- Behaviour on unfamiliar, large, dense or real tables. All seven images were development examples: the reader was built against them, and the same person wrote them and their answers.
- Other agents or models, or a session with less fixed context.
- Variation between repeated runs. There was one pass.
- Whether a shorter guide would do better.
Record source and dates
Copied on 2026-09-21 from cups/tables/docs/evidence-agent-use-2026-09.md in dogwonder/kettle-cups at f131b3ab4d15d1028641390524ec9e780c57e5d9. This page is a reviewed copy of that evidence note. Building the site runs no model and starts no agent session.
Sessions ran on my subscription, so nothing was billed per token. Raw session output stays on my computer; only the counts above are published. The reader’s exact model versions and file identities are on the Tables evidence page.