quiz / test / midterm
quiz / test / midtermresult: fail (auto_fail). Ledger, failures JSON, and human review are sealed.
witness
Witness seals every Go test, benchmark, and fuzz run into a timestamped record, and an independent custodian holds the copy. When the auditor samples or counsel asks, you produce evidence instead of recollection.
ENV darwin/arm64 · 10 cpus · 5 parallel
PROFILE FINAL · 2x test repeats · 84 packages · 4,941 test functions · 59 fuzz targets
BUDGET pkg cap 2h3m33s · test est 14m22s · fuzz budget 7m18s · bench budget 15m0s
Live activity
PASSED14/14
passedPASSED65,720/65,720
passedRUNNING89/124
github.com/yourcompany/yourcodebase BenchmarkHostWAITING0/59
waitingRUNNING1.5 MiB/10 MiB
file 10 · 4.1 MiB current · 98 MiB totalWAITING0/9
waiting for run completionMODEFINAL
TESTS65,720 OK
BENCH89/124
RECORDSEALED
Official run record being sealed and timestamped.
Continuous evidence
standing by connecting live unavailable
— of continuous fuzzing
Awaiting live evidence.
Peachfuzz sends millions of malformed, unexpected, and adversarial inputs through the code.
It uncovers crashes and security flaws that ordinary tests can miss before customers encounter them.
Runs continuously. Every figure above comes from tamper evident, replayable run records.
Evidence model
Most teams can show that tests passed. Fewer can show it to a third party years later.
Tests, benchmarks, profiles, and fuzz runs execute where your code lives. Your source never leaves home.
tests · fuzz · benchmarks · profiles
The run folds into a hash linked ledger, gets a timestamp from an authority that isn't us, and seals. We verify it and keep a copy.
replay · verify · timestamp
Years later, an auditor, a buyer, or a court asks. You hand them a record instead of a recollection.
3rd party copy · later proof
The problem
Enterprise security review tends to move past whether the code shipped and onto what ran before it did, and who besides you can vouch for the answer. Four specific problems stand between our tests pass and we can prove it. Witness exists because every team meets all four the first time someone asks.
Anyone can produce a document once a dispute starts. Courts, auditors, and buyers discount it, because the one thing it cannot prove is that it existed before the trouble did.
CI retention is usually well run and usually accurate. What it cannot do is separate the record from the party who controls it, which is the same reason financial statements go to an outside firm.
Audit prep and legal discovery turn into engineers rebuilding last year from CI scrollback, tickets, and screenshots. Companies spend millions producing records for a single case. Most of that is the price of not having kept them.
CI proves a job exited zero. It does not say which tools ran, at which versions, under which flags, or what was preserved. A second question about tool versions, flags, or retained output has to be answered from somewhere other than the badge.
Teams say
Enterprise asks
Enterprise stakes
Enterprise customers buy trust, and trust gets reviewed. Every framework pushes the same question back onto engineering: prove the standards operated before the code shipped.
Security review becomes evidence review: what ran, what failed, and what record existed before anyone asked.
Profile, budgets, tools, versions, flags, and why each default exists. The recipe is part of the record.
Tests, benchmarks, profiles, and fuzz output are retained with the result rather than discarded at the end of the job.
Hash linked events, manifests, attestation, timestamp receipts. Verifiable later, by anyone.
Markdown for people. JSON for machines. Same facts.
Your source and secrets stay home. We keep only the sealed result your agreement allows: the copy that still verifies when someone argues.
Witness proves what ran, what was preserved, and what still verifies. It does not certify your company, audit your controls, or promise perfect software. Nothing honest ever does.
Compliance map
Certification work draws evidence from identity, cloud, source control, tickets, monitoring, vulnerability, endpoint, policy, and people systems. Witness helps with one technical slice: it produces a sealed record of Go quality gates while the work happens, so the compliance platform and reviewer can sample a real run instead of asking engineering to reconstruct one from CI scrollback.
Five rooms, one question: prove it. Each of them needs an artifact rather than an assurance.
A buyer, auditor, or assessor asks for SOC 2, ISO, FedRAMP, CMMC, or HIPAA evidence, with a deadline attached. Without a record, this is the point where engineering stops shipping and starts searching.
Engineers run tests, race, shuffle, count, benchmarks, profiles, fuzz, and respected Go security tools where the source already lives.
Witness turns the run into human reports, machine JSON, ledgers, sidecars, hashes, artifacts, timestamps, failures, and profile proof.
Off Grid holds a sealed copy outside your systems, so the buyer verifies the record themselves instead of trusting the company that produced it.
The next review asks again. The same software-gate evidence can be sampled again without pretending it represents the rest of the control environment.
Witness helps a company complete certification evidence work by making one software-engineering evidence stream contemporaneous, sealed, portable, and independently retained. The customer's control environment, GRC workflow, auditor, assessor, certification body, and authorizing authority keep their own jobs and decisions.
Who it is for
The buyer, the auditor, the insurer, the counsel, the incident reviewer. Witness exists for the person who says: show me.
Success or failure, every run becomes a human report, machine JSON, a hash linked ledger, a timestamp receipt, and preserved proof.
Markdown for reviewers: outcome, action items, repro command, retained outputs, ledger references.
human_review.mdFailure class, crasher hash, corpus counts, reproducer argv, grade, policy violations, remediation hints.
machine_failures.jsonGrade, profile policy, tool table, SBOM hashes, sidecar checks, ledger-chain status.
final_certificate.md/jsonSequenced JSONL facts: run start, tests, packages, fuzzing, checks, profiles, seals, verification.
ledger/ledger.jsonlAn RFC 3161 receipt from an authority that isn't us. The receipt fixes the time from outside the run, and it is checkable against the authority's own trust root.
tsa.json + timestamp.tsrCPU, memory, block, mutex, benchmarks, fuzz corpus, crashers, stdout, and stderr stay with the result.
profile_proofs/*.profInspect the run itself, tools, versions, flags, and preserved output, instead of a summary of it.
Point SOC 2, ISO, CMMC, FedRAMP, or procurement evidence at a sealed record with hashes and timestamps.
Failure evidence, repro commands, retained output, and an independent chain to argue from later.
See whether the quality recipe actually operated: race, shuffle, repeats, fuzzing, benchmarks, profiles, budgets.
The workflow
Your code runs on your machine. Witness writes the record. We keep the copy. The day it matters, nobody has to take your word for anything.
witness lifecycle
Command tapewitness quizwitness test ./...witness midterm ./...witness final ./...witness mcat ./...witness verify witness_testimony/<run-id>_final/Observed in /Users/d/code/fun
result: fail (auto_fail). Ledger, failures JSON, and human review are sealed.
66,336 ledger events. Tests, fuzz, profiles, manifests, anchors, and TSA receipt retained.
Chain, fold replay, completeness, and terminal event all verify.
Generated files
artifacts/final_certificate.mdReviewer-readable verdict: outcome, grade, policy, tool table, hashes, and verify status.
artifacts/final_certificate.jsonTyped form of the same verdict for automation, audit import, and later comparison.
artifacts/machine_attestation.jsonThe metrics bundle: checks, tests, benchmarks, fuzz passes, ledger events, and sidecar status.
artifacts/anchors/*.jsonlTimestamp-ready records that bind retained files, hashes, and proof material to the run.
artifacts/retained_facts/*.jsonlSharded pass records and run facts that can be inspected without replaying CI memory.
checks/, benchmarks/, fuzz/Captured stdout, stderr, profiles, corpora, and crashers for the work the tool actually performed.
SHA256SUMS + indexDigest map for the bundle, so missing or modified evidence is visible during verification.
timestamp.tsr + tsa.*Off Grid calls the TSA, records the time, and returns the receipt that proves when the bundle existed.
What it does
The tests, analysers, and benchmarks your team already runs are not visible to anyone outside the build. Witness runs Go's own machinery plus the analyzers serious teams respect, and records everything worth arguing about: tool, version, flags, diagnostics, outputs, and why each default exists.
Tool inputs
facts / hashes / replay
Sealed outputs
Tool dossier
Catalogued from the Witness check registry: defaults, streams, issue signals, and why each tool belongs in the evidence bundle.
Compiles the target closure, runs the tests, and records JSON output, stdout, stderr, timings, and the repro command.
Race exposes data hazards. Shuffle exposes order dependence. The exact flags and seeds are sealed, so a reviewer can rerun the same claim.
Benchmarks run as evidence phases. CPU, memory, block, and mutex profiles are retained where the profile asks for them.
Fuzz targets run under profile budgets. Corpora, crashers, failing inputs, and repro commands are retained, not summarized away.
JSON output, so rule IDs, severities, and locations stay machine-readable in the sealed bundle.
Symbol-level scanning against the Go vulnerability database. OSV records and call-stack evidence are preserved.
Uber's nilaway as a real finding source: analyzer diagnostics are issues; package-load failures are tool errors, honestly classified.
JSON findings with rule ID, CWE, severity, confidence, and location. Defaults skip fixture, vendor, generated, and test-only noise.
Finds unchecked errors in authored source, ignoring generated and vendored code by default.
The Go tools deadcode pass, including test executables, so test-only call paths count.
Flags authored code over cyclomatic 10, skipping vendor, fixtures, tests, and generated files.
Catches repeated production literals. Diagnostics define truth, not exit codes.
The Go fieldalignment analyzer with tests included, so layout waste has nowhere to hide.
It runs go test, then turns checks, benchmarks, profiles, and fuzz targets into one repeatable evidence habit.
Every fact lands in a hash linked ledger: sequenced, validated, canonical.
The record carries the Git commit and artifact hashes. The proof matches the exact code, not roughly the right week.
Grades are computed from ledger facts, and the computation is replayable.
One run, one bundle: ledger, manifests, attestation, receipts, reports, sidecars.
Official builds ship a tool bundle per platform for Linux amd64 and arm64, macOS arm64, and Windows amd64, each with SHA256 sums and a signed attestation.
Pinned versions, trimpath, VCS provenance, and CGO disabled, so the same source produces the same binary hash across rebuilds.
Off Grid retains the sealed copy: independent proof the record existed and verified.
Evidence doctrine
Pick the profile that matches the moment. It carries the tools, flags, budgets, and retention rules. The recipe becomes a matter of record, not memory.
Evidence doctrine
Every setting exists because the artifact has to hold up in front of an engineer, a compliance owner, and counsel. Those three read the same artifact for different reasons, so it has to answer all three without a translation layer.
The append-only ledger owns the truth. Reports and certificates are projections of the ledger, and verification fails if a projection no longer matches it.
Facts are structs, closed enums, and validated schemas. The verifier refuses through 274 typed error identities, each naming the specific check that failed.
Verification replays the facts and rejects broken chains, drift, and mismatched sidecars. It runs offline against the bundle contents, so no party to the dispute has to be trusted.
A failed run publishes evidence too: repro commands, preserved output, explicit disclosure.
An independent copy can be checked by a party who was not involved in producing it.
The verifier, the timestamp, the ledger, and the manifest each fail on mismatch rather than on judgement.
Crashes, disk pressure, and seal failures do not erase evidence. A reserved ledger region guarantees the terminal record lands.
Settings table
| Profile | When to use it | Timing policy | Why it differs |
|---|---|---|---|
| witness quiz | Fast affected feedback while an engineer or agent is still working. | Race-scaled package timeout floor 20 minutes; aggregate safety floor 40 minutes; no benchmark or fuzz surface. | Race and shuffle are on, affected targeting is on, and the loop is short enough to run before a change grows stale. |
| witness test ./... | Normal development confidence across the requested target set. | Race-scaled package timeout floor 25 minutes; aggregate safety floor 60 minutes; short benchmark and fuzz budgets. | Two test repeats, race, shuffle, benchmarks, and fuzzing expose flaky tests, order dependence, data races, and input-sensitive failures before they become customer problems. |
| witness midterm ./... | Broader pre-merge confidence when the change deserves more than the daily loop. | Race-scaled aggregate safety floor 90 minutes; test budget floor 50 minutes; benchmark and fuzz budgets deepen from test. | Keeps the same evidence surfaces as test, then gives them more room to expose flaky, slow, or input-sensitive failures. |
| witness final ./... | Release-grade forensic evidence before production, customer delivery, or audit review. | Race-scaled package timeout floor 40 minutes; aggregate safety floor 150 minutes; test budget floor 60 minutes. | Verbose evidence, two repeats, race, shuffle, CPU profiles, memory profiles, and sealed artifacts create the record you expect to defend later. If one repeat fails, the failure is recorded. |
| witness soak ./... | Long endurance pressure for code paths where flakes, heat, time, or resource behaviour matter. | Package timeout floor 30 minutes; aggregate safety floor 24 hours; minimum duration 1 hour; max parallelism capped at 4. | Benchmarks and fuzzing stay on for sustained pressure while race and shuffle are off to keep endurance runs stable. |
| witness mcat ./... | Maximum confidence endurance run when the review bar is highest. | Inherits soak intent with race and shuffle on; aggregate safety floor 24 hours; minimum duration floor 1 hour. | Combines endurance pressure with race and shuffle so the record shows more than a quick green pass. |
| witness debug ./... | Verbose local diagnosis when the operator needs to understand a run, not create a customer-facing release record. | Race-scaled package timeout floor 25 minutes; aggregate safety floor 50 minutes; no benchmark or fuzz surface. | Keeps race and shuffle on, turns verbose output on, and avoids heavier evidence surfaces. |
| witness verify <run-dir> | Replay a sealed bundle from the run directory, ledger directory, or ledger file. | Runs when evidence is challenged, handed to a reviewer, or recalled from storage. | The ledger is canonical. Verification rejects broken chains, drifted manifests, mismatched sidecars, and report projections that no longer match the facts. |
Profile times are authored policy floors and safety bounds. Witness derives the concrete run from the selected profile, discovered workload, target set, machine characteristics, and effective parallelism, then records the actual timings in the sealed bundle.
Proof record
Witness keeps the tool flags, trust posture, retained copy, certification ecosystem, and rollout path in one reviewable record.
sealed copy
Why trust Off Grid Software
Witness exists because we needed proof that BLINK was actually great, not merely green in a terminal. We built it for ourselves first, and the BLINK release record below is the one bundle we can show end to end.
It began as our own release standard. The current release seals its own evidence: 65,720 test passes, 59 fuzz targets, a 66,336 event ledger, verified at grade 100.
The tests, analysis, security checks, and benchmarks your team already runs stop being invisible. They become work a reviewer can examine instead of work you have to describe.
A sealed copy lives outside your CI, your laptop, and your artifact store. Independent, when it counts.
The bundle verifies offline. If an artifact changes, verification fails. We could vanish tomorrow and your proof would not.
Witness seals the bundle where the work runs. Off Grid receives the finished proof and cannot turn custody into permission to rewrite it.
RFC 3161 receipts, multiple authorities raced, trust roots embedded. The record is sealed before the argument starts.
Witness records execution evidence, nothing more. Governing law, liability cap, and reliance limit travel inline with every sealed index.
We do not only stamp green runs. Failure records verify with the same discipline.
An audit firm sells judgment. A custodian sells custody. We never grade your engineering. We hold the sealed record, prove it never changed, and let verification speak. The narrower promise is the one that survives cross examination.
Where it fits
Keep everything you have. Witness does not certify companies or replace auditors. It gives everyone in the room something better to point at: a chain of custody for what ran, what was found, and what was sealed.
Certification ecosystem
Witness helps the tools and professionals already carrying your certification. Each system keeps its job; Witness supplies the sealed software-run record they can map, sample, and review.
Keep GitHub Actions, Buildkite, GitLab, or the runner you trust. Witness wraps the relevant run and emits a portable record without replacing execution.
Vanta, Drata, and Secureframe collect evidence, map controls, assign owners, and manage the audit workflow. Witness gives that workflow a sealed run-and-release artifact.
Keep the scanners and analyzers that find defects. Witness records which tool ran, against which code state, what it reported, and whether the sealed record still verifies.
Keep Jira or GitHub Issues for ownership, remediation, exceptions, and incident follow-up. Witness is technical execution evidence, not the task-management history.
The qualified reviewer chooses procedures, samples evidence, tests controls, and reaches the conclusion. Witness helps the company answer those evidence requests; it never issues the result.
The source-free sealed copy can sit outside the systems under review and be recalled later. That independent custody is the narrow role Off Grid must deliver reliably.
Enterprise rollout
Start where the review pressure is real. Prove value on one narrow path. Widen when it earns it.
One Go service, one workflow, one audit requirement. Your first sealed bundles.
Drop the binary into CI. Run quiz while developing, final on release, with the Git commit bound into the result.
Choose which sealed copies Off Grid retains. An independent trail for when the stakes are high.
Feed the sealed artifacts to Vanta, Drata, auditors, customers, and trust portals.
Widen from one workflow to release gates, waivers, exceptions, and retention rules.
Every tier seals and verifies the same way. Moving up changes how long Off Grid holds the locked copy, not the signing setup customers have to manage.
Buyer checklist
Ask them of Witness too. Every answer below is checkable against a bundle you can run yourself.
When it matters
You need it on the day someone asks what you did before you shipped. That day is usually scheduled by someone else.
Retention and custody
Companies do not audit their own books. The statements go to an outside firm because a record held only by the party being reviewed carries less weight, however accurate it is. Software evidence has the same problem, and custody is the fix: Witness seals the record on your machine, and Off Grid holds your locked copy as an independent custodian. Think escrow agent, notary, chain of custody. We do not own it, edit it, or grade it. We hold it, so you can produce proof when your customer, auditor, buyer, regulator, or court asks what happened.
1 year on Bronze, 3 on Silver
For the buyer, auditor, or security reviewer who has to check your record without taking your word for it.
Your run is sealed on your own machine, and a locked copy sits with an independent custodian, ready the moment proof is asked for.
10 years on Gold
For certification, procurement, and dispute work, where the question is not what you claim but what you can produce.
You log in and retrieve the sealed record yourself, the same afternoon your customer, auditor, regulator, or counsel asks for it.
Set by your plan
For teams that still need proof long after the build, the review, the incident, or the deal itself has moved on.
Bronze covers your first audit year, Silver the certification cycle, Gold the long tail of procurement, regulation, and legal exposure.
Witness creates the sealed record on your machine. Off Grid holds your locked copy so you can produce independent proof when a customer, auditor, buyer, regulator, or court asks.
The going rate
A price only means something next to the alternative. These are the figures companies already pay to be believed. Read them as invoices, then add the cost that never appears on one: the engineering weeks spent assembling the evidence behind each of them.
Evidence hunts, sample responses, and security questionnaires, taken off the roadmap and handed to someone who did not sign up for it. It never appears on the audit invoice and it is usually the largest line. Price it against your own salary bands.
Your payroll, not a surveyReadiness consultants tell you which evidence to produce. Your engineers still have to go and produce it. The fee below buys the checklist, not the work.
The line item nobody budgetsReadiness, consultants, and the audit itself. Then $15K to $40K every year to keep the letter current.
Linford & Company, SOC auditors (opens in new tab)That is the GAO's number, not ours. Staying authorized runs another $200K to $500K a year.
U.S. GAO, report GAO-24-106591 (opens in new tab)The median a major company spends producing records for a single case. Most of it is lawyers reading.
RAND Corporation (opens in new tab)Charged to over 100 firms by US regulators for one failure: records they could not produce.
SEC & CFTC enforcement (opens in new tab)Investigation, notification, litigation, and a year of explaining yourself.
IBM Cost of a Data Breach 2025 (opens in new tab)A missing certification stalls the contract, and the buyer rarely tells you that is why it went quiet.
A-LIGN Compliance Benchmark (opens in new tab)Hold those numbers. A full year of Witness on Bronze costs less than the annual upkeep on the SOC 2 letter alone, and a year at any tier costs less than one lawsuit's discovery. What you are buying is not compute. It is an independent copy of the proof, held somewhere you cannot quietly revise it, which is the part that stops being independent the moment you hold it yourself.
Pricing
Every plan starts with a one-time thirty-day free trial and is billed monthly after that, buying the custody described above for a different length of time. Nothing is charged during the trial, and cancelling before day thirty costs you nothing. Three things then carry across all three tiers. Custody is rolling rather than prepaid, so the window holds while the subscription holds and cancelling in month three buys three months plus the export window rather than the full tier term. Your rate is locked from your start date for the whole of that window. And once the trial converts, all sales are final: there are no refunds, credits, or prorated cancellations, so cancelling stops the next charge rather than returning the current one.
| Tier and window | Who needs it | Why it is worth it |
|---|---|---|
| Bronze, 1 year | Funded teams heading into a first SOC 2 or ISO 27001 cycle. | Covers the whole observation period, so the auditor samples a sealed record instead of a reconstruction. |
| Silver, 3 years | Compliance-sensitive teams that live in the standards year round. | Spans a full ISO certification cycle, including the surveillance audits in between. |
| Gold, 10 years | Finance, healthcare, government, and defense programs. | Holds the long record for procurement and regulators, with an expert who can take the stand. |
Published list prices, the same for a funded startup as for the Fortune 100. No negotiated rate, no Contact Sales button.
Thirty days free on every tier, one trial per customer. Nothing is charged until the trial converts, and cancelling before then costs nothing.
Your rate is locked from your start date for the whole of your tier's window. A later list price rise applies to new subscriptions, not to yours.
$69 USD per month for the whole organization
Works on Go only
Teams that need a durable internal quality record and will hold every copy themselves.
$578 USD per month for the whole organization
Works on Go only
Teams heading into their first SOC 2 or ISO 27001 cycle that need an outside copy of the quality record.
$3,150 USD per month for the whole organization
Works on Go only
Compliance-sensitive programs that require three years of custody and a staffed review path.
$7,000 USD per month for the whole organization
Works on Go only
Finance, healthcare, government, and defense programs.
FAQ
No. Today the commercial promise is intentionally narrow: Go. Witness is built around Go tests, benchmarks, profiles, fuzzing, and the surrounding release evidence. If you do not ship Go, it is not for you yet. There is no non Go path today, and no announced date for one.
No. Certifications come from a control environment, management discipline, and the relevant auditor, assessor, or certification body. Witness does something narrower and more valuable than a badge claim: it creates and retains sealed technical evidence showing what ran, what passed, what failed, what artifacts existed, which hashes identify them, and when the record was sealed. That evidence can support certification, recertification, procurement, incident review, and litigation, but it is not itself a certification.
No. CI still executes work. GRC platforms still manage controls, owners, tickets, policies, and audit workflows. Auditors still decide audit procedure. Counsel still decides legal posture. Witness creates the sealed technical record those people can rely on: machine-readable results, human-readable reports, ledgers, manifests, timestamps, and retained proof. It complements those systems by giving them evidence with custody instead of screenshots and after-the-fact summaries.
CI still owns execution. Witness wraps the relevant release, test, benchmark, profile, and fuzz work so the result becomes a sealed record tied to the code state and policy profile. The operational goal is simple: engineers keep their workflow, but the organization gets a record that survives procurement, audit, and dispute review.
Not the loop your engineers live in. The quiz and test profiles are the developer path and add sealing overhead measured in seconds on top of the test time you already pay. The heavy profiles are release grade and meant to be scheduled rather than sitting in front of a merge: final for a release candidate, soak and mcat for endurance work you run out of band. One clarification worth making, because the numbers invite it: the timing floors published in the profile guide are safety ceilings that stop a runaway run, not expected durations. A 24 hour aggregate floor describes the outer bound before a run is abandoned, not how long a run takes. Witness runs go test as the engine, so the underlying test time is whatever it already is; what Witness adds is the recording, and the recording is cheap.
A passing record is not just a green badge. It includes a human-readable report, machine-readable certificate, hash-linked ledger, manifests, timestamp receipt, run attestation, profile and policy facts, checksums, and verifier material. The purpose is reviewability: humans can understand the run, machines can compare the run, and verifiers can check whether the record still matches itself.
The ledger is the ordered source of truth for the run. Events are sequenced, hash-linked, and replayed during verification. Reports and certificates are projections from that record. That matters because a polished PDF is easy to produce after the fact; a consistent ledger, manifest, timestamp, and verifier path is much harder to fake without leaving a mismatch.
Because failures are often the most important evidence. A failure can show the gate operated, the defect was caught, repro material existed, and the release did not pretend everything was fine. Witness treats failures as first-class records: reason codes, machine failure JSON, human review material, repro commands, retained output, crashers where relevant, and the same sealing discipline as a passing run.
A certificate states what ran, what verified, and what evidence was preserved. A guarantee promises an outcome. Witness does the first, not the second. The distinction matters in review because a certificate can be checked against the bundle, and a guarantee cannot.
No, and saying so plainly is part of the product. Witness executes the tests you wrote and seals what happened. It forms no opinion on whether those tests were worth running. A suite built to go green proves that it went green and nothing further. Tests earn their keep through the failures they were designed to cause: the assertion that would have caught the regression, the input nobody sanitised, the boundary the code was never asked about. A wall of tests that cannot fail is worse than no tests at all, because an absence is honest and everyone can see it, while a false green is a claim your team will plan around. Sealing one does not improve it; it makes a weak claim permanent and checkable, which is not the same as making it true. Writing tests that genuinely try to break your code stays your job, and it is the job that decides what a Witness record is worth.
We can help prove that a sealed Witness record existed, belonged to your account, matched its hashes and manifests, and verified according to the verifier material in the bundle. We cannot prove your tests were complete, your controls were perfectly designed, your software had no defects, or your company was legally non-negligent. Witness proves the record. It does not turn engineering judgment, audit judgment, or legal judgment into a magic certificate.
No, and the distinction matters. An audit firm examines your work and issues an opinion. Off Grid holds evidence and never grades it. The closer comparisons are an escrow agent, a notary, or chain of custody in forensics: we can attest what arrived, when it arrived, and that it has not changed since, while offering no view on whether your engineering was good. That is a narrower promise than certification, and it is the one we can keep under cross examination. Custody solves the same structural problem an outside audit firm solves, without pretending to be an opinion.
A customer-owned copy of the sealed Witness evidence bundle. Witness creates the record on your machine. Off Grid holds the locked copy as custodian so you can retrieve it later. We do not own the evidence, edit it, train on it, sell it, or treat it as our operational data. The point is independent custody: when your customer asks for proof, the answer is not limited to your own CI records or your memory of the run. On access: the evidence is yours, we do not own it, edit it, sell it, mine it, or use it to train systems, and the contract says so. There are three circumstances in which anyone here would open your bundle: you ask us to during a support request, a court orders it, or the law compels it. Where we are permitted to tell you, we will. The commercial promise is custody, not inspection.
No. The trust model is built around custody, not editorial control. Witness produces the sealed record where your work runs. Verification depends on the bundle, hashes, manifests, timestamps, and verifier material already sealed into it. Off Grid keeps the locked copy; custody does not grant a capability to invent a better history. If the retained record is changed, verification fails.
No. Witness runs where your code lives. We do not want your source code, secrets, customer databases, or production data, and the custody product is not designed around receiving them. The retained evidence is about the run and its proof material: reports, ledgers, manifests, hashes, timestamps, and verification facts.
No. The retained copy is useful because it is independently held, but the evidence model cannot depend on our website being available or trustworthy. A sealed bundle is meant to verify from its own contents: ledger, manifests, hashes, timestamps, and verifier material. The website helps you find and retrieve what we hold for you; it is not the source of truth.
They should not have to trust our marketing. The bundle is designed to verify: hash-linked ledger events, manifests, timestamps, reports, machine attestations, sidecars, and replay material. Off Grid adds independent custody. Your customer can ask whether the record existed before the dispute, whether it verifies, and whether the copy was held somewhere you could not quietly rewrite. The claim your customer checks is the bundle, not our role in holding it.
Because CI logs are still your records, inside your systems, subject to your retention, access, rebuilds, migrations, and admin privileges. That is the same structural problem financial reporting solved by requiring an outside firm, and it is why a reviewer can discount an internal record without disputing its accuracy. A retained third party copy changes the posture: the proof exists outside the system being reviewed, held by someone who does not benefit from the answer, and it verifies on its own contents rather than on anyone's word.
No, and we do not market that promise. Witness releases are immutable instruments. A result produced by Witness 2026 is a statement under the Witness 2026 rules, tools, threat model, evidence format, verifier, and consulted data. Each released Witness instrument is retained with its binaries, evidence format specification, verifier, data snapshots, checksums, commit identity, build metadata, tool metadata, release notes, assumptions, and limits. It is independently timestamped, so a historic result stays verifiable under the exact rules, tools, and threat data that produced it. The clean promise is not 'latest Witness reinterprets everything forever.' The clean promise is: a bundle produced by Witness X is verified with Witness X. Use the Witness instrument that produced the bundle unless a later release explicitly says it supports that older format. Do not use Witness 2036 to reinterpret a 2026 result by accident, because the 2026 result is a statement under the 2026 instrument. That is easier to explain in court or an audit than a claim that a current release reinterprets every past format: the old release is preserved as an artifact with its assumptions and verifier, while current Witness stays free to represent today's rules, tools, and threat model.
That is responsible change, not a contradiction. Your 2026 bundle proves what Witness observed in 2026. New Witness may observe new issues on the same code because the tool, rules, threat model, or threat data improved. The threat landscape evolves daily, and no tool can predict future flaws, future exploit paths, or future reviewer expectations, including this one. When you remediate and seal a new passing result, the delta is itself evidence of responsible change: historical state, new detection, remediation, renewed attestation.
No. Negligence is a legal conclusion. Witness helps establish contemporaneous technical facts: what ran, what failed, what passed, what was preserved, what policy was in force, and when the record sealed. Counsel can use those facts. An auditor can sample those facts. A buyer can review those facts. Witness does not replace the judgment of any of them.
Negligence turns on standard of care, and standard of care is argued from contemporaneous records. One common line of attack is not that the tests were weak but that the evidence was assembled after the complaint landed. A hash linked ledger, a timestamp from an authority that is not us, and a copy held by an independent custodian answer that attack directly: the record existed in this exact form before the dispute, and it still verifies. Sealing every release also makes these ordinary course records rather than litigation artifacts. Witness cannot win a lawsuit or make negligence go away, and no evidence system can. It can spare your counsel the alternative, which is engineers rebuilding last year from CI logs, Slack threads, and memory while the meter runs.
Yes, and we would rather say so here than have you discover it later. Failed runs seal with the same discipline as passing ones, so a record showing a gate failed before a release is discoverable too. We consider that a feature. A record that only ever contains passing runs is easier to challenge, because the absence of failures is itself a question. The teams this serves are the teams that act on failures: for them the full record shows a gate caught a defect and the process worked, which is a far stronger story than a year of unbroken green nobody can verify.
They can try, and you should assume that anyone determined enough will. Here is what we commit to when it happens. We notify you before producing anything, unless a court order legally forbids us from telling you. You get a reasonable window to move to quash before we respond. Where a protective order is available, we will seek one. We are the custodian of your record, not a party with an interest in disclosing it, and we will not treat a request as routine simply because complying is easier than resisting. Two things are worth being clear about. We cannot promise to defeat valid legal process, because no custodian can, and a commitment to fight every request regardless of merit would be a promise we could not keep. And what we hold is the sealed evidence bundle, which contains reports, ledgers, manifests, hashes, timestamps, and verification material. It contains no source code, no secrets, and no customer data, so the material reachable through us is narrower than what sits in your own systems.
It creates a second holder of a record you already had, which is a fair thing to weigh, so here is the honest arithmetic. The evidence itself was always discoverable from you, because it describes your own release process and lives in your own systems first. Custody does not create new discoverable content; it creates another place the same content exists, held by someone with no stake in the outcome. In practice that usually helps rather than hurts, because the version we hold is the one nobody can be accused of having curated, and its existence before the dispute is exactly the fact that is hardest to establish after one starts. The tradeoff worth naming plainly: once you routinely seal evidence, allowing custody to lapse during a live dispute is itself an act a court can look at. That is an argument for keeping custody current when it matters, and it is a reason to think about this before you are in a dispute rather than during one. If your counsel wants to review the custody terms before you subscribe, we would rather they did.
Off Grid Software operates from Ontario, Canada, and Ontario law governs the customer agreement. Retained evidence starts in Google Cloud's northamerica-northeast1 region, which is Montreal, Quebec. That is where it starts, not a commitment to where it stays. We can and will move it, and add regions alongside it, wherever redundancy and resilience need us to, and we will do that without asking first. A custodian whose evidence sits in exactly one place is a custodian with one way to lose it, so treat any single region as a starting position rather than a guarantee. If a specific residency is a hard requirement for your program rather than a preference, do not rely on our default: self-hosted deployment puts the location under your control and your audit scope instead of ours. It is licensed and priced separately, and it is a different trade rather than a cheaper one, because we hold nothing and therefore cannot vouch for custody of anything. Two further implications worth stating rather than leaving you to work out. We offer this service to businesses in Canada and the United States, and we do not market or sell it into the European Economic Area, the United Kingdom, or Switzerland. Do not send us personal data of individuals located in those territories: that needs a signed addendum, we do not offer one by default, and we make no representation that this service satisfies the GDPR or the UK GDPR. For customers who care about the CLOUD Act, the honest position is that the data sits in Canada under Canadian law while the storage provider is a United States headquartered company, and that distinction matters to some legal teams and not others. If your program requires evidence to sit somewhere specific, self-hosted deployment is available under a separate licence.
Timing is often the whole dispute. A record that appears after the customer asks, after the auditor samples, or after the lawsuit starts is a weaker record. Witness is designed to show the evidence existed when the work happened, then Off Grid custody keeps extending the locked-copy expiry for as long as the account is paid and in good standing. Read the retention windows on the plan cards as rolling, not prepaid. Your tier sets how far back custody reaches at any moment, and it holds while the subscription runs. Buying Gold and cancelling in month three does not buy ten years of storage; it buys custody for those three months plus the wind-down window to export what we hold.
Because the expensive part is not running a test binary. The expensive part is credible proof when a buyer, auditor, regulator, or court asks for it. Bronze protects the first audit year. Silver protects the certification cycle. Gold protects the long record. We price against the cost of not having independent evidence, not against CPU minutes.
It is a reasonable question, and you are right that the storage itself is inexpensive. The cost sits somewhere else. What custody buys is our commitment to stand behind a record: to hold it under a locked retention window, to keep it in a state where it verifies, to account for how it was stored if a court asks, and where your plan includes it, to write a custodian's declaration describing how we received and held it. Each of those is an obligation rather than a file, and obligations accrue for as long as we hold the record. A custodian holding evidence indefinitely for accounts that have lapsed takes on commitments it has no way to honour properly, and we would rather offer a window we can genuinely stand behind than a longer one we cannot. That is also why the tiers are priced the way they are. Gold costs more than Bronze because ten years of responsibility is a larger commitment than one year, not because ten years of disk costs more. And it is why a lapsed account gets a wind-down period rather than immediate deletion: the record belongs to you, so the right thing is to give you time to take it with you.
Not during your guaranteed term. The rate you start at is locked from your start date for the full length of your tier's window: one year on Bronze, three years on Silver, ten years on Gold. Your start date is the day your thirty-day free trial begins, not the day it converts, so taking the trial does not shorten the window or move you onto a later price. A company starting Gold today holds that monthly figure until the same date in 2036. If we raise list prices next year, the new figure applies to new subscriptions and to anyone returning after a lapse, never to a term already running. The reasoning is straightforward. Custody is only useful if you can rely on it for the whole window, and a vendor able to reprice a dependency at will has not offered custody so much as storage with leverage attached. Two boundaries worth stating plainly. The guarantee follows continuous payment, so an account that lapses and later resubscribes starts again at the list price current at that time. And the guarantee covers your term rather than forever: when a ten year Gold term ends, renewal is priced at whatever is current then, with the same guarantee running from that date.
Your window shrinks to the new tier's, and anything outside it leaves custody. Moving from Gold to Silver takes your reach from ten years to three, so bundles older than three years fall out of the retained set. We do not delete them the moment the change takes effect; you get an export window to retrieve anything the new tier no longer covers, the same courtesy an account closure gets. Two things follow from that. Downgrading is not a way to shed cost while keeping the long tail, and if the old records are the ones that matter for a specific audit or dispute, export them before you change tiers rather than after. The bundles you export keep verifying offline regardless, because verification never depended on us holding them.
Custody is a paid service, not a free warehouse after the lease ends, and the runway is longer than most people expect. The day a payment fails nothing changes and our processor retries. About a week later, once those retries are done, Witness goes read-only: it stops accepting new runs and keeps verifying everything you already sealed. Around thirty days in you get a second notice saying your data is scheduled for deletion in about sixty more days and that you should export now. On the third missed invoice the account is treated as closed and deletion follows once the storage expiry passes. You can clear the balance yourself at any point before deletion by signing in and paying; there is no reactivation fee and no ticket to raise. The part worth knowing: that read-only ability never expires. What you already produced stays readable and verifiable whether or not you subscribe again, because what you made is yours.
There is a trial. There are no refunds. Every tier, Bronze through Gold, starts with a one-time thirty-day free trial of the full service: real custody, real sealing, real verification, not a reduced demo. We take a payment method up front so the subscription converts without a gap, and nothing is charged during those thirty days. Cancel before day thirty and you are not billed at all, which is the window in which to decide whether custody from us is something your organisation wants. Once the trial converts, all sales are final: there are no refunds, credits, or prorated cancellations. Cancelling stops the next month rather than returning the current one, and the custody window you have already paid for is honoured in full, including the export period. We would rather state that plainly here than have you discover it after a charge. The reason we can be this firm is that we try to leave nothing for you to find out later: the trial, the tiers, the retention windows, the rate lock, the wind-down process, the jurisdiction, and what happens to your evidence if you stop paying are all written on this page before you spend anything. If a term here does not work for your organisation, the right time to tell us is during the trial rather than after the first invoice.
Security questionnaires increasingly ask for artifacts rather than attestations. Witness gives you a concrete answer: here is the sealed record, here is the retained third-party copy, here are the hashes and timestamps, here is what passed and failed, and here is the verification path. That shortens the distance between 'send us proof' and 'here is the proof.'
Not yet, and we are not going to dress that up. Witness has been used on real Go codebases outside our own, but the custody service is new and we are not currently holding retained evidence for any customer. There are no reference calls to arrange and no logos to show you. Saying otherwise would be the exact behaviour this page argues against, since a page insisting that self attestation is weak has no business offering nothing but self attestation. What we can offer instead is the thing a reference call is a proxy for. Every claim on this page is checkable without talking to anyone: run Witness against your own repository, seal a bundle, verify it offline, and try to alter it and watch verification fail. Our own BLINK release record is the one bundle we can show end to end, and we know it is our own homework. If being an early custody customer is not a risk your organisation takes, that is a reasonable position, and the honest advice is to wait until we can point you at someone other than ourselves.
It is a fair question and the honest answer is that Off Grid is deliberately small, which is exactly why the trust model does not rest on our size. Most vendors ask you to trust their headcount, their certifications, and their balance sheet. We ask you to trust a hash chain, a third party timestamp, and offline verification, none of which improve if we hire fifty people. The evidence verifies without us, and the bundle is exportable at any time. The one thing our size genuinely affects is service: support is direct rather than tiered, and the founder is the person who shows up for an expert testimony engagement. Judge that as you would any specialist firm. What our size cannot affect is whether your proof survives, and that is the part the architecture settles.
Your bundles keep verifying, and that is not a reassurance, it is the architecture. A sealed bundle verifies from its own contents: ledger, manifests, hashes, timestamp receipts, and verifier material. The timestamp comes from an authority that is not us. Nothing in the verification path calls an Off Grid server, so a bundle you hold verifies on a laptop with no network in a world where this company no longer exists. What you would lose is the independently held copy and the retrieval service, which is why the wind-down commitment matters: if we cease operating, the same export window applies as for any account closure, and you should keep your own copy of every bundle regardless. We designed the product so that depending on us is optional, and we would encourage you to put the same question to any custody vendor you evaluate.
The most useful answer is what the vault does not contain. We never receive source code, secrets, credentials, customer databases, production data, or PHI, because Witness runs where your code lives and seals only the evidence: reports, ledgers, manifests, hashes, timestamps, and verification material. That narrows the blast radius of any incident on our side to material that is, by design, meant to be handed to auditors and adversaries anyway. Retained copies are encrypted at rest, custody is locked for the retention window so stored bundles are not casually replaceable, and any tampering with a retained copy causes verification to fail rather than passing silently. Off Grid does not hold SOC 2 or ISO 27001 certification today, and we would rather state that plainly than let it come up later in your vendor review. Those certifications are meaningful, and we understand the teams buying this product often hold them. What we offer alongside that gap is a custody model you can verify directly rather than take on trust. If your vendor review requires a certified subprocessor, please raise it early and we will tell you honestly whether we can meet the requirement.
Because payment collection is not the place to improvise. Checkout, cards, receipts, tax handling, and payment security belong on Stripe's platform. Our server still owns product identity, plan rules, and prices, so the browser cannot invent a cheaper plan. Stripe collects payment; Off Grid grants the entitlement that matches the server-side product.
No question matches that search. Book a call and ask it directly.
witness
That is the one thing no vendor can backfill for you. One service, one workflow, your first sealed bundles, and a walkthrough scoped for your security, compliance, and legal reviewers in one session.
Book your evidence pilot (opens in new tab)