Solutions

Ask one model if something is true and you get one confident sentence. Ask another model and you may get the opposite, just as confident. You still do not know the question is contested.

Swarm Explorer is the core Verafy platform. A claim goes to a panel of 250+ models. The screen shows each verdict, each confidence, and the spread. LLMs act as judges, so the contrasts and the biases stay visible.

The Churchill claim in the screenshot comes back No at 93%. Meta's model is at 0%. Qwen is at 95%. The split is the information.

That asks more of a reader than a green tick. The Inspector puts the same check on the page where the claim appears.

This is the flagship of Verafy. The company built a developer community of 4,000 before the crypto market turned.

The explorer is still up, and it still answers.

I recorded an interview with my father. Transcription was the easy part. A life does not arrive in chapter order.

An oral history is one person's memory. If the tool fills the gaps quietly, the book reads well and you cannot trust it.

Lineage turns that interview into a family history. Swarms of research agents gather records from archives and museums. The pipeline builds a structure you can inspect before it writes a word.

It transcribes the session, builds a family timeline, splits the tape into stories, shapes each one in his voice, assembles chapters, places photographs and records, and compiles a print-ready PDF. The same history reads online.

Every proper noun becomes an article. Every claimed relationship carries the sentence it came from, with a source and a timestamp. If there is no quotable passage, the claim is dropped.

The rebuild banner is the check. Eleven relationships kept. Six discarded for lack of evidence. All seventeen would have made a fuller tree, and a worse one.

There are 1,086 stubs. I use them as the question list for the next recording.

1,334 articles. 923 people, 196 places, 159 events, and the rest.

The book is The Book of Daniel. It reads online and it prints.

A smart contract can only enforce what someone can write as code. Most of what people want enforced is a policy, a claim or a condition about the world, and today those decisions leave the chain and come back as someone's word.

Two changes. Contracts are written in words: context, a question, a payment and a short list of exits. And a validator is an AI model wrapped in a harness that takes requests in, checks every pinned source, deliberates, commits and reveals a signed vote, and runs the contract's exit. A jury of harnesses from different labs rules, and a ruling only counts when their agreement clears the contract's bar.

Each harness also carries a routing agent: a keyblock that keeps API and wallet keys encrypted and hands out scoped keys, a banker that accepts any token and swaps between them, an API router that plugs into and pays AI APIs and cloud hosts, and a payment wallet. It is built on DeepSeek Harness, with juror mode as a plugin.

There is no token, on purpose. Escrow stays on the chain where the requester paid, in their asset, and harnesses are paid in the same asset. That removes the usual reason to build a network around a coin, and it leaves two problems open: how to weight nodes without stake, and how to compare bonds posted in different assets.

Security is economic, not mathematical. Commit and reveal stops copying and lab diversity stops one lab's blind spot deciding, but forged evidence fooled every model in testing, and a hosted model can't prove which model served a vote. Proofs of inference would close that gap; today they exist for one open model and run to about 18.78 MB each.

A working prototype, not a network. Five contracts ruled live on five labs' models through OpenRouter, 5.9 to 30.1 seconds each and $0.0163 in total (measured Nov 6). Five DeepSeek Harness processes on five labs' models sealed a block from their reveals, with every other tool locked. The live forecast fell below its bar, which is the escalation path working as designed. Built without venture capital and MIT licensed.

It ships three ways as of v0.0.2-alpha (Nov 6): an MCP server on npm, @verafy/mcp, with plugins for seven agents including Claude Code, Codex, Cursor and Gemini CLI; single-file binaries for Linux, macOS and Windows; and a Docker image. The agent is a client of the harness, never a juror, and live calls stay off until a spend cap is set.

The evidence in front of an AI jury is written by the parties. A model cannot reliably tell text it should weigh from text it should obey. An instruction hidden in a statement, an email, or a run of invisible characters is the attack, and more jurors do not help when they share the weakness.

Prompt Guard compiles untrusted text before any model sees it. It normalizes away invisible characters, look-alike and fullwidth letters, Unicode tag characters, base64, hex and percent-encoding. It separates statements a party is making from directives trying to instruct the reader. The render escapes the evidence so it cannot close or open a prompt section, and a SHA-256 pins the result so every juror derives the same compiled evidence from the same bytes.

The zero-width row is the argument for the design, stated as a measurement. Normalization takes the raw rules from 0% to 93.3% on that row.

The own-suite numbers come from a suite written by the same people who wrote the rules. That is why the held-out deepset split is reported next to them.

BIPIA at 0.67% is a real failure against indirect injection embedded in ordinary documents, and it is published rather than omitted.

Measured 10 November 2026 and labeled measured in results/scanner.json. Detection means the guard flags the injected text, so the model sees it as a quoted directive. A test of whether the attack still changes a real verdict has not been run.

Cost: 1,749 texts, 269.9 KB, 0.479 ms per KB, zero model calls.

MIT licensed. It is a research prototype used in front of every juror in Verafy Harness, and it has not been audited.

A dev-tools company's documentation is now read by AI coding agents as well as by developers. When the docs block an agent's user agent, render only with JavaScript, or have no llms.txt or OpenAPI spec an agent can find, the agent works from guesses. The team that owns the docs rarely sees it happen.

DevRadar takes one input, a docs URL, and scans the public surface the way an agent, a competitor and a developer would. The free scan runs stages 1 and 2 today:

• Docs. Reachability, redirects, sitemap coverage, how much of each page needs JavaScript to read, and whether a quickstart and code samples can be found.
• Agent readiness. robots.txt policy for agent crawlers, whether the docs answer an agent's user agent differently from a browser's, llms.txt, OpenAPI discoverability, and whether an advertised MCP server answers.

Stage 2 is the earlier AgentReady scanner, folded in. agentready.rexstjohn.com now redirects here. The remaining stages, competitors, events, personas, targeting and the assembled report, are rolling out.

Paid plans add a weekly re-scan:

• Watch, $149 a month. Weekly agent and docs scan with change alerts, and a weekly sample-code test run.
• Radar, $599 a month. Adds a weekly buzz scan, events and CFPs for your regions, and three tracked competitors.
• Program, $2,500 a month. Unlimited competitors, a monthly working session and a maintained 3, 6, 9 and 12 month roadmap.

Plans are arranged by email for now. There is no checkout yet.

Every finding carries the raw artifact it came from, the actual status line, headers or snippet, or it is dropped. A check that cannot run is reported as unknown, never as a failure, because a false positive in a report forwarded to an engineering lead cannot be taken back.

The first finding is never paywalled. If the scan sees a 403 to ClaudeBot, the free report shows the 403. Paid plans buy breadth and recurrence, not the first fact.

There is no score, grade or leaderboard, and reports are unlisted. A score starts an argument about methodology and moves the conversation off the finding that mattered. The cost is a report that is harder to summarize in one line.

The scanner is polite by design. It makes at most 60 requests per domain per day across the whole platform, competitor domains included, and it does nothing that looks like a security test.

People hit claims while they are reading. The tools in that moment hand back one confident answer from one model.

A Chrome extension in the side panel, built on Verafy. Three modes. A full read maps the page, finds up to 40 checkable claims, highlights each one in place, and checks the most central ones against independent sources. A quick score checks only the main claims and returns a truth score out of 100. Or select one sentence and right-click to check just that.

A full read adds cliff notes for the page and a list of whose perspective it carries and whose is missing. Neither affects the score.

The model does not pick the verdict. It argues for and against each claim, every argument has to quote a search result, and a small fixed solver decides which arguments survive.

The outlet and the claims are scored separately. A reliable outlet can still carry a weak claim. One combined number starts arguing about the outlet.

I built it in about thirty minutes. The first version of the idea took days.

The same panel is on the Swarm Explorer.

Election forecasts come from one model or one pollster. You get a single number and no view of how far the people making it disagree.

Forecast puts the 2026 US midterms to a panel of five models: GPT-6 Astra, Claude Fable 5.1, Gemini 4 Argon, Grok 4.7 and DeepSeek V4 Pro. Each one gives a lean for every Senate race and every House district. The page pools them into one forecast per chamber, draws both maps state by state, and keeps a daily history you can rewind to any day before Election Day.

Reading a published race is free. Running a fresh forecast costs 200 credits.

The page shows each model's call next to the average instead of hiding it. On the October 28 run, Gemini 4 Argon gave Republicans an 82% chance of holding the Senate while the panel average was 42%. A single-model forecast would have printed one of those numbers with no sign of the other.

The cost is coverage. Models decline some races, so each one answered between 374 and 424 of the 435 House districts, and the page counts the gaps rather than filling them.

AI models answer the same question differently, and a reader has no easy way to tell where they agree, where they lean, or whether an answer can be trusted.

Verafy is a suite of tools for checking AI answers. It scores bias across a fixed question bank, checks the page you are reading, compares a claim across models, compares views on questions with no right answer, forecasts elections, applies a community's own rules to its disputes, lets an AI jury enforce contracts written in English, and runs an AI validator anyone can operate.

Eight products and two research demos, SVMLLM and EVMLLM, built under the Verafy name and linked from verafy.ai.

I open most agent tools after something has already gone wrong. I wanted a screen I would open because I wanted to see the work.

Sixteen agents produce more output than anyone can review. The useful question is which two decisions need a person right now.

An isometric office. You can see what the agents are doing, assign them tasks, and group them. Each agent is a figure at a desk: Scribe, Researcher, Auditor, Lawyer, Prototyper. Each project is a room they move between. Who is working, who is idle, and where the two failing checks are, without reading a log line.

Under the floor: an append-only record of every event, live traces and evals through Weave, a spawn bar that creates agents by role, and a queue of things a human has to approve or reject.

The floor makes sixteen agents readable at a glance. Sixteen log streams do not.

A game view can make you feel informed. The append-only record is what you can audit. The floor sits on that record.

Sixteen agents across seven projects. 12,176 events in the record. Two things waiting on a human.

Ask the same contested question of several models and the answers scatter. Some refuse, some hedge, some lean. One question cannot show whether that lean is the model's habit.

The Bias Detector runs a model against 565 versioned contentious questions, political, geopolitical, and cultural. The bank does not record a correct political position. Any model on OpenRouter can be tested, and a standing roster covers 20. A jury drawn at random from different companies scores each answer, so no vendor grades its own work. Jev, from TypeSafe AI, does a cheap first pass. The jury writes the rationale. Each model gets a report card: where it leans, where it refuses or hedges, and how it compares with the rest of the roster.

The results are inscribed on Solana through IQ, built by Zo, founder of IQ6900, so a published run cannot be rewritten after the fact.

The Swarm Explorer compares models one question at a time. This runs the whole bank and keeps score, so a later run can show whether a model moved, and in which direction. The set is versioned so those runs stay comparable.

Every score on the site today is simulated. The question bank, the method, and the interface are real. The live scoring pipeline is not finished. A simulated report card is not a measurement, which is why the product says beta.

A naive run, frontier models judging every answer, costs about $155. Batch pricing, a cheaper cross-company jury, and the Jev pass bring a run to about $13. Almost all of what remains is the cost of the models being tested.

The beta is up at bias.verafy.ai. Live runs are not. The account of it is Introducing the Verafy Bias Detector.

Some questions have no right answer, such as whether there is free will or what the meaning of life is. Asking a single model gives one confident answer anyway, and hides how much thinkers have disagreed.

Perspective scores each question on a scale from no right answer to factual. For open questions it lays thinkers' views side by side instead of naming a winner, so you can see how many answered and compare them.

In beta at perspective.verafy.ai, as part of the Verafy suite.

A smart contract does exactly what its code says, bug or not. The rules people care about are written in words, like "never pay an unknown wallet more than a million dollars," and someone has to turn each one into code and get it right.

Write the rule in English. One model compiles it into a short list of steps, a second looks for loopholes, and a person signs off. The steps are inscribed on Solana with IQ Labs. When a request comes in, AI models from different labs each read the rule and the request and sign a vote from their own wallet. The contract acts only on a quorum.

The same check can stand in front of an existing contract: a Solana program requests a ruling with a question, the evidence, the jury it wants and an escrowed payment, and acts only on a final, signed ruling for that exact action. That part is proposed as three draft SIMDs: inference programs, evaluators and attestations, and rulings with disputes and challenges.

The jury never touches the money. It can only pick among the outcomes the contract lists, and caps in code limit what any outcome pays. That keeps a wrong ruling bounded, at the price of a contract author having to list outcomes up front.

The weak point is evidence. In testing, a forged correction fooled all ten models. Models from different labs still share blind spots, so a jury reduces single-model error and does nothing about bad inputs.

A signature proves which wallet voted, not which model ran. Anthropic's FlashProve research proves a model's output without revealing its weights, but today it is slow and covers one open model, and one proof is about 18.78 MB, against 1,232 bytes per Solana transaction. So the drafts keep proofs off chain and put a commitment, a bond and the right to challenge on chain instead, the way optimistic rollups and oracles work.

The hot-wallet run is real on a local Solana validator: inscription, signatures and transfer. Its votes were scripted from the rules. The other recorded runs use real model calls. Everything runs on play money. The design is now written up as three draft SIMDs, open for discussion in SIMD discussion #724 and not yet submitted as pull requests.

I run recurring AI agent jobs every day on my own sites and projects. Each job started as a prompt and a schedule. Over time its goals, its checks and the lessons from past runs ended up in notes, scripts and chat logs. When a run taught me something, the next run never saw it, and I had no score to tell me whether a job was getting better.

Looper keeps each job in one Markdown spec. The spec has nine sections: objective, evals, sources and instructions, quality control, macros and recursion, learning, schedule, roadmap and OKRs.

Each run does the work and scores it against the evals. The loop logs what raised or lowered the score and edits the sections of its spec it is allowed to edit. A bank view lists every loop with its schedule, its last score and the change since the run before.

It is in development and I am its only user. A loop cannot change its own objective, evals or OKRs. Every edit is logged with the reason, and if the next score drops, the loop goes back to the last version. I write the specs and decide what ships. AI agents write much of the code and the first drafts, and I review them.