Introducing Crawford — A Claude Code AI Agent for Cheap Right Answers
Free data first, verified twice, receipts on every row
Hudlow Fire Department covers a stretch of Rutherford County, North Carolina. At some point the department stopped paying for its website, and the domain reverted to a GoDaddy parking page — an ad lot where a fire department used to be. On July 4th I asked the best-funded research AIs on the market one simple question: what's this department's official website?
OpenAI handed me the parking page. Claude handed me the parking page. Exa handed me the parking page. Three companies, three price tags, the same wrong answer — delivered with full confidence, because a parked domain still loads, and a page that loads looks alive to any machine that doesn't actually read it.
This post is the story of Crawford — the research agent I built in Claude Code that reads the page. It caught both parked domains in that test without spending a cent. Its finished proving run scored 34 of 39 hand-verified rows correct, and every answer it committed was right, for $0.77 of total spend — about half a cent a row. It also missed in ways that changed the design, and I'll show you exactly where. At the end there's a public benchmark, built so the whole market — my own agent included — gets scored the same honest way. Annual subscribers can install Crawford today.
The chip lesson
When Apple shipped its own laptop chip in 2020, the pitch had a strange shape. Intel had spent decades selling raw speed. Apple's press release claimed something else: the world's best CPU performance per watt. The fastest chip loses to the chip that does the most work per unit of power — because power is the thing you actually run out of.
Research AI in 2026 is sold the way Intel sold chips. Every vendor races on raw accuracy; the price sits in a separate PDF; and the two numbers are never printed side by side. Crawford is built on the other axis: right answers per dollar. Performance per watt, for research.
That axis changes every design decision — what runs first, when money gets spent, what the output records. And it ends in a scoreboard: the last section of this post is the benchmark I'm building that measures every tool on the market this way, with answers verified by paid humans and zero favors for my own agent.
The market, mapped
There are five shelves you can buy web research from, and I swept all of them while building this.
Spreadsheet platforms. Clay is the anchor: the company announced $100 million in revenue last December, its January employee tender priced it at $5 billion, and the 2026 State of GTM Engineering survey found 84% of GTM engineers use it. Its research agent, Claygent, answers questions per row for credits.
Research-agent APIs. Parallel and Exa (valued at $2.2 billion) sell research as a per-question API call. Parallel's customer list includes Clay itself, per Parallel's own funding announcement — the platform the market buys from has a supplier.
Model-vendor search. OpenAI and Anthropic both price web search at $10 per 1,000 calls plus tokens. Bolted onto a cheap model, this is what actually runs per-row in most production pipelines.
Data vendors with agent bolt-ons. Apollo, ZoomInfo, Cognism. These query their own databases — useful, but bounded. If the answer lives on a med spa's website instead of in their records, the bolt-on can't go get it.
DIY inside a coding agent. Operators wiring research directly into Claude Code, no platform in the middle. This is Crawford's shelf.
Every shelf shares the same two blind spots. Nobody can read the bill: list prices are public, but the adding-up — this row took two tries on a bigger model, that column ran across 4,000 rows before anyone sampled it — only surfaces on the invoice. Henley Wing Chiu burned $700 in two weeks and wrote up his exit at bloomberry.com. Opaque credit pricing was the one complaint that came back from every category I swept.
And nobody publishes an error rate. Accuracy is buyable — in my own test, OpenAI hit 95% at $0.25 a row. Across a 30,000-row market list that's $7,500, and it still handed me both parked domains. All watts, no efficiency.
Why I built it
I verify GTM datasets for a living, and the job keeps teaching the same lesson. A dataset a client had already shipped listed 6 websites as live that were actually parked or dead — every one loads, every one passes an automated status check. A blind audit on another client's list measured roughly 65% of one data aggregator's contact names wrong. The whole doctrine I work from is knowing more about the buyer's situation than the buyer does — and that only compounds if each fact is cheap and true.
The uncomfortable discovery underneath: most of what GTM teams pay per-row for is sitting in free public sources. Government registries, open map data, public certificate logs. The market prices every question as if it needs a frontier model. Most questions need a lookup.
Why didn't I just use Claygent? Fair question — I've advised Clay since 2020, and Claygent is genuinely good. Four gaps sent me to build anyway:
The prompts are hard. A Claygent mission that works takes real engineering — hard enough that I built AutoClaygent, a tool whose entire job is writing Claygent prompts.
It doesn't learn from its own misses. There's no loop that builds an answer key, scores the run, and fixes the cause of each error cluster. Every mistake stays yours to find, row by row.
The model choice is your gamble. Cheap model or frontier model changes both the price and the accuracy, and nothing measures that tradeoff on your rows before you commit a whole table.
Every run is time-boxed. The stubborn rows — the answer buried in a state registry, the slow government site — are exactly the rows that need more time than the box allows.
So I built the thing I wanted to buy. Crawford lives in Claude Code, and the name works the way you'd hope: when a list needs verifying, you send Crawford in first.
The free floors
Every row rides the same elevator, floor by floor, and gets off at the first floor that settles it. The free floors come first, and there are more of them than you'd guess.
The web, already scraped
Never scrape what's already scraped. Common Crawl is a public copy of the web — it answers "has this domain served real content recently?" from your own laptop, before any live request. Overture Maps publishes 69 million open place records and Foursquare publishes 108.7 million more, each carrying the business's own declared website and phone. Chrome's public usage dataset covers 18.4 million websites real people actually visit. Domain zone files list which domains even exist.
And underneath all of it: government registries. Fire-department rosters, medical-license files, SEC filings, nonprofit returns. If a regulator already keeps a list of the thing you're researching, that list is the backbone — the live web is for the residue. Crawford's catalog holds 316 free sources, each one tested before it earned a slot.
The wire checks
Before reading any page, check the wiring. A domain that doesn't point anywhere is dead. A domain whose name servers belong to a known parking company is an ad lot. A domain with no mail setup probably has no organization behind it. These checks run thousands of rows a minute on a laptop and clear 10–25% of a typical job before anything else runs.
Reading the page like a skeptic
Both parked domains in my test returned HTTP 200 — the "everything is fine" signal every uptime checker trusts. So Crawford reads the body. Parked pages carry sentinel phrases they can't hide ("this domain is for sale," ad-frame scaffolding). And there's the garbage-page trick: ask the site for a page that can't possibly exist. A real site says "not found." An empty shell serves the same husk for the garbage page as for its homepage — and now you know.
The certificate heartbeat
Every website's security certificate is recorded, at issuance, in a public log anyone can read. That log is a biography. The first certificate is the site's birthday. Steady renewals are a pulse. Renewals that stop, on a domain whose name servers just moved to a parking company — that's a death certificate, with a date on it. Of every tool in my test, Crawford was the only one running this check.
The free quotas
Google's Knowledge Graph — the database behind the info boxes on a search results page — allows 100,000 free lookups a day and returns the official website Google has on file for an organization. Wikidata, Wikipedia's structured sister project, records official-website claims too. Neither is trusted alone. When two unrelated sources name the same website, the row settles — for free. When they disagree, or Google simply doesn't know the tiny volunteer fire department, the row rides up a floor instead of getting a guess.
Absence must be earned
Early on, Crawford would stamp "no website" when its sources came up empty — and a hand-check found several of those sites existed. Now the rule is structural: before any absence verdict, Crawford brute-forces about 30 naming-convention guesses learned from the batch itself (fire departments cluster around patterns like hudlowfd-dot-com) plus one half-cent search. Silence is never evidence. A row with nothing found escalates with the attempt on record.
The cheap floors
When the free floors can't settle a row, the meter starts — at pennies.
Credits you already own come first. If your Clay plan sits at 60% utilization, those credits are cheaper than any new dollar, so Crawford spends them before spending yours — and only on the jobs where Clay genuinely wins, like verified-email and mobile-phone waterfalls that bill only when a provider delivers.
Then metered pennies. A page-to-text service costs hundredths of a cent per page. One structured search call — about half a cent — goes out per stuck row, once, with the question phrased so the answer comes back in a checkable format. A small, fast model reads the fetched pages for about a quarter per thousand rows.
Crawford doesn't take the search engine's word for anything. Every answer that comes back still passes Crawford's own identity checks plus a free fetch of the answered page. On the finished proving run, that free fetch bounced a wrong-state twin and two county websites the search engine was confident about. The half-cent search floor settled 22 of the run's 39 scored rows — with zero wrong answers.
The expensive floor
The last floor is a Claude agent — one per stubborn row, and only for the rows nothing cheaper could settle. On a healthy run that's the last few percent.
The agent runs on a budget: 3 to 15 tool calls depending on difficulty, a hard stop when three sources agree, and a forced best-answer-with-confidence when the budget runs out — it can't dig forever. And it never starts from scratch. The row arrives as a packet carrying everything the cheaper floors already proved: this domain is parked, this org is in the wrong state, this source is an aggregator. Cheap facts ride along as constraints the expensive agent can't un-know. That rule has a scar behind it, which I'll show you in the trap section.
The measured price of the top floor: closing 12 stubborn rows cost $0.50 when Crawford jumped straight to the agent. Running the designed order — cheap search first, agent last — closed all 12 for $0.06. Honest label: that six-cent number is an in-sample demonstration (the search partner was picked on those same 12 rows), so treat it as proof the mechanism works, and nothing more, until the benchmark at the end of this post scores it on fresh rows.
How it can be sure
Every floor, free or paid, reports its answer with a confidence level, and Crawford enforces three bands. Nearly certain: commit the answer, write the evidence and the cost. Nearly certain the other way: commit "not found," same receipts. Everything in between gets held, never guessed. A held row climbs to the next floor, and if the top floor can't settle it either, it lands in a review queue a human can route anywhere.
Committing takes more than confidence. Four rules gate what counts as true:
Two sources make a truth — and they can't be cousins. A fact counts when two sources with separate origins agree: the department's own site plus the state fire-marshal roster. Data aggregators never corroborate anything — that blind audit that found ~65% of one aggregator's names wrong is why. Two aggregators agreeing is one bad copy machine quoting another.
Identity has to be proven, not resembled. A candidate website must tie to this specific organization — name, place, and jurisdiction — before it can match. A same-name fire department two thousand miles away bounces off this rule; you'll meet it in the trap.
Only positive evidence settles a row. Missing from a database kills nothing. Presence proves; absence escalates.
The verdicts tell the truth even when it's awkward. The proving run forced a verdict I hadn't designed: a department whose own Facebook page names its domain — and the domain's server is broken. The row now reads "their domain, no usable website." A tool that only answers "live" or "dead" would have shipped a lie in either direction.
The review queue holds tradeoff questions, with stakes attached: "spending about two dollars closes roughly 40 held rows — worth it?" Answering one question updates the run's plan. One decision fixes a category, never one row.
How it tests itself
Crawford assumes its own runs are wrong until a test says otherwise, and the test is built fresh every job.
Blind agents build an answer key first. A sample of 100–200 rows gets drawn — half random, a quarter from the rows the pipeline found suspicious, a quarter spread so every region and size of organization shows up. Separate verification agents each take just one to five rows and derive the truth from primary sources — the org's own site, the government registry, one more independent root — without ever seeing what the pipeline answered. A fact enters the key only when two unrelated sources agree. The same blind-verification discipline pulled 597 verified attendees out of a 3-minute screen recording in an earlier build; here it manufactures the exam.
Every run gets a grade out of 10. The scored run is joined against the key, and the grade weighs what a buyer would weigh: accuracy and completeness carry half the grade between them; quality of the cited evidence and cleanliness of the output carry most of the rest; cost-efficiency and consistency close it out. A run below 8.0 doesn't ship. The grade always prints next to the measured cost per row, because the two numbers together are the product — accuracy alone is the drag-race trap this whole post is about.
Misses get fixed at the cause, never the row. Wrong answers get clustered by what they share — same source, same floor, same page shape. One diagnosis per cluster, one fix to the plan, re-run the affected slice, re-score. In the first proving run, four of the five wrong answers traced to a single cause: the engine declared "no website" without a discovery step. One fix — the absence-must-be-earned rule you read three sections ago — retired all four, plus every future row that would have failed the same way.
The receipts, in order. July 3, first proving run, two 150-row slices of real client data: 8.37 out of 10 against the 8.0 bar, at $0.00 of marginal cost — free floors only, paid floors switched off, which left about half of one job's rows sitting held. (Marginal means what it says: the free floors ride on subscription compute and free quotas that fuller accounting has to price — the benchmark at the end does exactly that.) That run also caught the 6 parked-or-dead sites the client's dataset listed as live. July 4, after the fixes, full ladder on: 9.29 out of 10, 34 of 39 hand-verified rows correct, $0.77 total spend for the whole 150-row job. Every one of the 34 answers Crawford committed survived the key. All five misses were rows it held as unresolved where the truth was "no website exists" — its remaining failure mode is hesitating to declare absence, never shipping a wrong answer. One label that run has to wear: it was re-scored on the same locked key that taught the fixes. Its first test on questions it has never seen is the benchmark at the end of this post.
Then I set a trap
Those numbers came from Crawford grading itself, so I built a test where I knew every answer cold — and invited the market.
Thirty-nine North Carolina fire departments. For each: what's the official website? Twenty-seven have a real answer. Twelve have nothing, and the twelve are landmines — two parked domains that load fine, a county directory that looks official, and a twin: a real Creston Volunteer Fire Department with a real website, two thousand miles away in Kalispell, Montana. I built and locked the answer key before any tool ran, every row verified from two or three independent sources. When tools disagreed with the key I didn't trust the key either: eleven rows drew disputes, and I hand-checked all twelve rival answers live. The key survived every challenge.
What the trap caught:
Both parked pages fooled OpenAI, Claude, and Exa at the same time. That's the Hudlow story from the top. Its sibling — a domain serving a raw parking script — also took two of Parallel's five tiers.
The Montana twin worked. Claude matched the Kalispell department's website to the North Carolina row. So did Parallel's two cheapest tiers. Same name, wrong state, three tools.
Claygent ran clean and hit a wall. On the rows it finished, one miss — calling a live site dead, the error that costs coverage instead of poisoning your list. Then Clay's API stopped me: "You can only test-run Clay actions directly 25 times a day." Batch scale means building inside Clay's app.
Parallel was the strongest rival on the board — and 39 rows is as much weight as that sentence can carry, for reasons two sections down.
The failure with a name: a false alive — handing over a parked or dead domain as a live website. It's the expensive kind of cheap. A false alive sails through every downstream step — enrichment, sequencing, a rep's morning — and poisons all of them. Every tool that answered all 39 rows shipped at least one.
Including Crawford. Twice.
The first miss: on the parking-script row, Crawford's page-reading flagged the trap correctly, for free — then its matching step committed the county government's website for the same department at high confidence. The rule banning county directories existed; the guard enforcing it ran too late in the sequence. One miss, one root cause, one fix.
The second miss hurt more, because it was Hudlow — the trap Crawford had already beaten. When I paid to close the held rows through the top floor, the packet handed to the Claude agent didn't include the verdict the free floor had already earned: this domain is parked. The expensive agent re-derived from scratch and shipped the parking page — the same mistake as OpenAI, Claude, and Exa, purchased at the top of the ladder after the bottom had solved it for free. That miss became the design rule you already read: verdicts travel with the row.
Here's the full board, sorted by the number this post is about — measured price per right answer, cheapest at the top. Read it with its labels on: these are preliminary numbers from a 39-row probe, the full Blueprint Bench hasn't run yet, and at this sample size the gaps between the good tools sit inside the noise.
*Claygent's run stopped at Clay's 25-a-day cap — 15 rows never ran, and its completed subset skews toward the easier rows. Crawford's $0.00 is marginal cost only; its free floors ride on subscription compute the benchmark below prices at list. Crawford's two rows here are its pre-fix numbers, measured the same day as everyone else's — the 34-of-39 run from the previous section came after the fixes this trap taught, so it doesn't get to sit in this table. And at this sample size, the gaps between the good tools sit inside the noise — which is the next section.
Why nobody gets crowned
I had the victory post drafted — a dollars-per-right-answer column with Crawford's answers coming in 16 times cheaper than OpenAI's. Then I ran the same adversarial review on my own scoreboard that Crawford runs on its own output, and three flags killed it.
The best composed number was circular: I'd picked Crawford's escalation partner by watching it ace those exact 12 rows, then scored the pair on the same rows. The $0.00 wasn't the whole bill: Crawford's free floors ride on subscription compute, while every rival was billed at list — two accounting systems in one column. And 39 rows can't separate good tools: when I later ran the proper statistics on a bigger draw, no two tools on the board were distinguishable, and that math was right about the 39 too.
Every incident above survived the review — the parked pages, the Montana twin, the daily cap, both of Crawford's misses. They're dated, hand-verified, and sitting in a committed run directory. The ranking died. What replaced it is the last section of this post.
Where the rivals win today
The incumbents beat Crawford on real dimensions, and pretending otherwise would fail the same review:
A spreadsheet a non-engineer can drive. Clay's UI is the reason 84% adoption happened. Crawford is dispatched from Claude Code — my RevOps friends don't live there. Yet.
CRM writeback. Clay lands enrichment in HubSpot or Attio automatically. Crawford ends at a CSV.
Pay-on-delivery waterfalls. Clay's contact waterfalls bill only when a provider actually delivers. Crawford writes down its spend but doesn't yet route on pay-per-hit versus pay-per-attempt.
Watching for changes. Parallel and Exa both sell re-research when something changes. Crawford runs batches; it doesn't watch.
Calibrated confidence. Parallel publishes evidence that its confidence scores mean what they say. Crawford's are self-reported — its harness generates the data to check them, and nobody's drawn that curve yet.
Speed. The rivals answer in seconds, fast enough for inbound triage. Crawford is built for batch depth, and a hot lead won't wait for it.
Hostile websites. The proxy infrastructure that gets past bot-blocking sites is real, and Crawford doesn't have it.
Someone else keeping score. The rivals get benchmarked by third parties. Crawford's only tests so far are ones I ran myself.
That last line is the setup for the ending.
Blueprint Bench: performance per watt, scored
I went looking for the benchmark I should be citing instead of my own. I tried to trace the flagship accuracy numbers three major vendors publish; none of the three led back to anything checkable. Web-research agents get measured on essay-writing benchmarks. Nobody scores them on a med spa's website — the questions GTM teams actually pay per-row to answer.
So I'm building Blueprint Bench: the per-dollar benchmark for GTM web research, with answers verified by paid human panels and zero favors for the house.
A thousand fresh questions every quarter — ten question types, drawn live from public registries days before the run, so no model can have memorized them. Is this the business's website. Is this domain alive or parked. Who runs this org today. Does this person still work there. Whose email is this.
Every answer findable on the open web. Only one single allowed gated source for B2B profiles. Licensed private datasets are banned as questions and as truth.
Each question type carries its own named trap — the failure that costs real money: shipping a parked site as live, naming the previous chief instead of the current one, pattern-guessing an email nobody published, merging two people who share a name.
Truth comes from two panels of paid humans who never see each other's work. One panel judges the documented evidence. A separate panel researches every question blind, from scratch, no hints. A fact enters the key only when both panels and the machine derivation agree — and where the two panels disagree, that gap gets published too, because it measures how much evidence-framing sways people.
The house plays by visitor rules. The answer key's digital fingerprint posts publicly before any tool runs. Crawford's configuration is frozen and fingerprinted before the questions are even drawn — anything I tune after seeing results waits for the next edition. Every scored vendor reviews its own rows before the board publishes. Retired editions are open-sourced in full, with tripwires that expose anyone training on them. Crawford competes; it never referees.
The headline metric is Total Cost to Clear — the performance-per-watt number: what it takes to get 1,000 rows actually finished. The spend, plus a price on every wrong answer, plus the cost of routing every held row to something that can close it. Crawford's subscription compute gets priced at list like everyone else's. A free tool that ships poison stops looking free.
Where it stands: the harness is built and passes its 123 automated tests. A 54-row pilot has been drawn, keyed blind, and run against three cheap tools — total contestant spend, $1.08. The trap machine already works: one drawn business's domain expired two days before the draw and now serves a parking page, and two of the three tools handed it over as a live website. One fire department's chief can't be named from the entire open web — the roster literally reads "Chief Unknown," with two plausible wrong names one town over, waiting to be guessed. The blind human panel has come back: on all 13 rows where both hired researchers committed an answer, they matched the machine-built key, and the two rows humans got wrong both validate the traps. The evidence panel is still in its vendor's review queue. Crawford has not been scored on any of it.
And the early numbers cut against the house: on the small pre-Bench data, the best buy on the board is a rival's cheap tier, and pricing Crawford's subscription compute at list can only move Crawford's costs up. Crawford enters its own benchmark as the challenger. If it wins, you'll watch it earn that quarterly, on fresh questions, under a key it can't touch. If it loses, you'll see that too.
First full edition — all ten question types, the full board, Crawford included — is next. Estimated cost to produce: $400–580. Then every quarter, fresh.
— Written by Claude Fable 5, Approved by Jordan
Who Gets This
Above this line: the story — the market, the machine, the trap, and the benchmark. Below it: the exact build — floor by floor, rule by rule, formula by formula.
Free: the story you just read.
$50/mo (most readers start here): the build mechanics — every rung of the ladder with its real thresholds and tools, the adjudication rules, the answer-key harness and its grading formula — plus the Bench internals: all ten question types with their named traps, the two-panel truth pipeline and its consensus math, the neutrality mechanics, and the metric Crawford has to win.
$2,499/yr: Every tool I ship. Edge Copilot is how you talk to all of it through Claude Code. Current tools: Edge Copilot, AutoClaygent, Agent 7, Who to Target and What to Say, Blueprint Cloud, Technology Finder, Video List Extractor, Competitor Monitor, LinkedIn Engagement, Domain & LinkedIn Finder, Dossier Builder, PDF Contact Finder, TAM Contact Harvester, Find a Rep, Blueprint Playbook, Crawford. Whatever ships next is included. Plus all 3 courses + weekly office hours.