Every agency eventually receives the email. It arrives three weeks after a deliverable shipped, it is polite, and it asks one question: where did this number come from.
The answer decides what happens next. If it is a screenshot from a memory, the conversation becomes about trust. If it is a claim verification tool folder with a source card, the conversation becomes about the source, which is a much shorter conversation and a much better one to be in.
This page is the five proofs a claim verification tool has to produce for client work, and how to hand all five over in one reply. It is written for the agency case specifically, because a client deliverable has requirements that a personal blog does not.
[The client email, and the five artefacts that answer it.]

The email every agency eventually receives
A claim verification tool changes how that email reads. It is usually not hostile: it reads something like we had a question about the pricing comparison on page four, could you point us to where the figure came from.
With a claim verification tool in place, three replies are possible.
The memory reply, which is what you send when no claim verification tool was run. You remember checking it, you say so, and you go looking. If you find the source, the client learns that your evidence arrives after the question. If you do not find it, the client learns something worse, and you have taught them to check.
The apology reply. You say the figure needs correcting, you correct it, and you mention a process improvement. Honest, and it costs the confidence you had built up to that point.
The folder reply. You send the source card. It carries the quote, the date and the page. The client reads it, replies thank you, and the conversation ends in four minutes.
A claim verification tool exists to make the third reply possible, and to make it possible for a deliverable you shipped six months ago, by a person who no longer works with you.
Proof 1: the source link, clean
The first proof is the address of the page that said the thing. It sounds trivial and it is where most handovers fail.
Three requirements make a link usable in a client deliverable, and a claim verification tool stores what you give it rather than fixing it for you.
It resolves without a login. A link to an internal dashboard is not evidence for a client. Evidence has to be readable by the person questioning you, on the day they question you.
It carries no session parameters. A URL with a token in it expires, and an expired link in an evidence pack reads as carelessness even when the underlying claim was correct. Strip the parameters before you store it.
It points at the page, not the search. A search result URL is a snapshot of a query, not a source. The page behind it can change while the query keeps returning the old snippet, which is how a client ends up reading a different figure than the one you cited.
A claim verification tool records the URL as given, so the cleaning is your job at the moment of binding. Two seconds of deleting query parameters is the difference between a folder that ages well and one that does not.
Proof 2: the exact quote
The second proof a claim verification tool must produce is the sentence, copied, not summarised.
A quote does three jobs at once. It shows what the page said, it makes the comparison possible months later, and it demonstrates that somebody read the page rather than skimming a search snippet.
Three habits keep quotes usable.
Copy the row, not the cell. In a price table, the row label carries the subject and the cell carries the number. Copying only the number is how a claim ends up attached to the wrong product, and it is the failure that produced our own eleven day price error.
Copy the heading when it carries the period. If the table says annual and the cell says a figure, the period lives in the heading.
Keep the awkward parts. A quote with a caveat in it is stronger evidence than a cleaned one, because it shows the client exactly what the source committed to.
An agency that hands over quotes rather than links is an agency that gets fewer follow up emails, in our experience and in the experience of everyone we have asked.
Proof 3: the date, with the rule attached
The third proof is the retrieval date, and the rule that turns a date into a policy, which is the part of a claim verification tool purchase that clients actually feel.
A date on its own says when you looked. A rule says how long the look stays valid, which is what a client actually needs in order to trust a deliverable they are still using.
Our rule is short and it can be stated in a proposal: prices and availability are re-checked within thirty days of publication, statistics and reports within ninety. Anything older is re-checked rather than re-used, and if it cannot be re-checked, the claim is labelled as an estimate with its date in the sentence.
That rule is more useful to an agency than any software feature, because it is the thing you can put in a scope document. A claim verification tool that produces dates without a rule produces paperwork. Dates with a rule produce a service level.
[One source card with the retrieval date and the validity rule beside it.]

Proof 4: the subject, named the same way
The fourth proof is the one clients ask about without knowing its name, and the one a weak claim verification tool gets wrong. Does the source talk about the same thing the deliverable talks about?
A claim verification tool answers this by comparing subject words, and the answer is often no. The figure was correct, the source was real, and the source was about a different product, a different edition or a different year.
Two practices make this proof strong.
Name the subject in the claim itself. A sentence that says which product and which edition can be compared. A sentence that says only the amount cannot, and the client cannot check it either.
Record the tier when the claim names one. A price list showing all three editions supports a claim about any one of them. A page showing one edition supports that one only, and an agency that hands over the second kind of source for the first kind of claim will lose the argument, correctly.
The five proof structure is in the engine’s documentation, and the rule it enforces is deliberately one directional. That asymmetry is the most useful thing an agency can explain to a client in one line: evidence that shows the tier can support the tier, and evidence that hides it cannot.
Proof 5: the decision, with a name on it
The fifth proof is the one most teams skip, and it is the one that protects the individual who did the work.
For a claim verification tool, a decision is a verdict plus a person plus a reason. Supported, reviewed by someone, because the source names the same edition. Or unverified, reviewed by someone, because the vendor page has not been updated since the price change.
Why a person and not a stamp: because the point is accountability, and accountability is a name in a document, not a cryptographic claim about authorship. The hash in a proof folder proves the file was not altered. It does not prove who ran the check, and pretending otherwise would be the exact kind of overclaim this category is full of.
For an agency, the practical form is a line in the deliverable: verified by, on date, with a link to the folder. Ten seconds of typing that changes the tone of every later conversation about a number.
[The five proofs gathered into one reply to a client.]

How to hand all five over
The handover itself is a template, and a template is why a claim verification tool scales past one careful person.
One folder per deliverable, named for the client, the date and the asset. Inside it, the draft, the report in HTML and PDF, the proof file and the source cards.
One covering line in the delivery email: the claim verification tool report is attached, every figure in the deliverable has a source card, and the folder stays available for twelve months.
One escalation rule: if a claim is unverified at delivery, it is either removed or labelled as an estimate before the email is sent. Nothing ships with an open block, because the first question a client asks is the one you did not answer.
That is the whole handover, and it is what a claim verification tool buys you. It costs about four minutes per deliverable once the ledger exists, and it converts a question that used to damage a relationship into a question that used to end in four minutes.
A worked handover, end to end
Here is the whole thing as it happens, because a process page that never shows the process is a brochure.
Monday. The client asks for a pricing comparison page. It will carry nine figures across three competitors and their own product, plus two dates and a claim about response time.
Monday afternoon. The ledger is built before the draft, not after. Nine entries, one per figure, each with the URL, the row copied from the table, the retrieval date and the tier named. Two entries are weak: one competitor publishes a range rather than a price, and one page has no date anywhere. Those two are flagged in the note field, which is what a claim verification tool expects you to do with a source you do not fully trust.
Tuesday. The draft is written against the ledger. This is the part that surprises people: writing with the ledger open produces fewer claims than writing first and checking later, because you stop reaching for figures you cannot support.
Tuesday evening. The run. Nine claims extracted, nine bound, seven supported, two unverified. The two unverified claims are the ones written from the weak sources, which is exactly what a claim verification tool is for, and exactly why the notes existed.
Wednesday morning. The two claims are rewritten. One becomes a range with both endpoints and a date. The other becomes an explicit statement that the competitor does not publish a price. Both are now true, and neither needed a better source.
Wednesday afternoon. A style pass, then publication. The style pass happens after the block resolution, not before, because fondness for a sentence is what lets a wrong figure through.
Three weeks later. The client’s marketing manager asks where the response time figure came from, because their sales team cannot find it. The reply is a source card with the quote and the date. The conversation takes four minutes and ends with the client asking whether the same process can be used on their internal documents.
That last sentence is the commercial argument for a claim verification tool in one line. The deliverable was not better because the agency tried harder. It was defensible because the evidence existed before the question did.
What changes the second time
The first deliverable with a claim verification tool takes an hour of setup and forty minutes of work. The second one takes eleven minutes, and the reason is not software speed.
The ledger already exists when a claim verification tool runs the second time. Three of the nine sources are the same competitor pages, and the fourth is the client’s own pricing page, which does not change weekly. A claim verification tool run against a prepared ledger is measured in seconds, and the human time goes into the two or three claims that are genuinely new.
That is the compounding effect nobody mentions in the feature list. The expensive part of verification is not the checking, it is the first time you look. Every later draft about the same products reuses that look, which is why agencies that start this on one client tend to apply it to all of them within a quarter.
The trap is the reverse: an agency that rebuilds the ledger per project never gets the compounding, concludes the process is slow, and drops it. The fix is a rule, not a tool feature. One ledger per client, kept forever, extended rather than recreated.
Two artefacts that make the client relationship easier
Beyond the five proofs, two documents do quiet work.
A one page scope note, written from the same folder a claim verification tool produces. It states what is checked, what is not, how long a check stays valid, and what happens when a claim cannot be supported. Clients sign scope notes more readily than they accept assurances, because a scope note is a boundary rather than a promise.
A twelve month retention line. Evidence that disappears in a month is not evidence, which is why a claim verification tool writes files rather than dashboards. Saying in writing that the folder stays available for twelve months changes the client’s behaviour: they stop saving screenshots, and they start asking for the folder instead. That is a better relationship for both sides, and it costs a sentence.
Neither document needs a claim verification tool to exist. Both are worth more when the tool produces something to point at, because a scope note with no artefact behind it is a policy nobody can audit.
[The end to end handover as a timeline across one week.]

[Two documents that protect the relationship: the scope note and the retention line.]

What it costs an agency to skip this
Three costs follow from skipping a claim verification tool, and they compound in the order listed.
The rework cost. A wrong figure is found, the asset is corrected, the client is told, and the version history grows. About an hour, plus the awkward email.
The trust cost. The client starts spot checking. Every deliverable now arrives with an implicit question attached, and the account manager spends time answering questions that used to be unnecessary.
The pitch cost. When the account comes up for renewal, the buyer remembers the correction and not the fix. Nobody loses a contract over one figure. Contracts are lost over the pattern that one figure suggests.
Against those three, the cost of a claim verification tool and an hour of setup is small enough that the argument is not close. That is not a sales argument, it is arithmetic that any account director can do in their head.
Where the engine fits, and where it does not
The claim verification tool we built runs offline, produces the folder described above, and costs ₹2,499 for personal use, ₹6,999 for commercial use of your own products, and ₹14,999 for agency work with five named users.
A claim verification tool from us does not negotiate, does not search the web and does not rate sources. It compares what the draft says with what the ledger says, and it blocks when there is no witness. For an agency, the useful property is that the report survives a staff change, which is the same property that makes a client handover possible six months later.
If you want the method before the tool, how to fact check AI generated content is the long version. If you want the difference between a checker and a detector, which clients ask about, ai hallucination checker answers it. If the deliverable is a proposal or a report rather than a page, verify claims in a document covers the scale problem.
Google’s guidance on generative AI content is worth attaching to a client proposal, because it makes the review obligation the client’s as well as yours. The spam policies page covers what happens to a site that publishes unsupported claims at scale, which is the risk a client understands immediately.
[The report folder as a client deliverable, with the covering email.]

The agency routine below was last walked through on 21 November 2026, on a live client package.
SOVEL SAAKSHI is what an agency buys when the client asks for proof rather than an assurance, and the claim verification tool is the only part of it a client ever sees.
Three editions of SOVEL SAAKSHI differ in who may use the output, not in what the engine decides, so pick the edition from the client list rather than from the feature list.
Questions agencies ask about a claim verification tool
Is this different from a copy editing pass?
Yes. Copy editing checks the sentence against the language. A claim verification tool checks the sentence against a source. Both matter, and only the second one catches a figure that is right in the source and wrong in the deliverable.
Can the client see the folder?
Yes, and that is the point. The folder is designed to be read by someone who was not present: a claim, a quote, a date, a subject and a decision. If a client cannot reach the same verdict from it, the folder is not finished.
What about client confidentiality?
The engine runs offline, so drafts and sources never leave your machine. Nothing is uploaded and there is no account. That is one of the reasons the product exists in this form rather than as a web service.
How many people can use it under the Agency licence?
Five named users and five machines. The licence is about rights rather than features, so the engine is identical in all three editions. The named register is manual, which is the honest version of a licence that does not phone home.
Does it work on the client’s machine if they want to verify themselves?
The archive runs on Windows, macOS and Linux with Node installed. A client who wants to re-run a check can do it, provided they have the ledger, which is the artefact that makes independ24 verification possible.
How long does setup take for an agency?
An hour, once. Most of it is building the first ledger for the client’s core products. After that, a deliverable takes about four minutes of checking and one template email.
What happens when a claim cannot be verified?
It is removed or labelled as an estimate before delivery. Nothing ships with an open block. That rule is the whole difference between a process and a promise.
Is there a version for teams with a dashboard?
No. The v0.x line has no account system and no plan for one. A local tool that produces a folder is easy to audit and hard to overclaim. A dashboard invites metrics that look like evidence and behave like decoration.
The last thing worth saying to an agency buyer. Your client is not buying proofreading. They are buying the ability to defend a number to their own boss, and the five proofs on this page are exactly what that conversation needs. A claim verification tool that produces them is worth more than one that produces a score.