Decision · evaluate

Test the claims. Do not take them.

Seven tasks, in order, that exercise the parts of this system that are actually different — and a list at the bottom of the reasons you should walk away today. Both halves matter; a landing page that only has the first half is a sales pitch.

2.5hours7 tasks · 150 minutes · one afternoon
  1. 0115m

    Learn the two nouns

    DoRead the change model and the changes-vs-lanes concept page.

    You should seeYou can say, without hedging, what a change is, what a lane is, and why recording work and advancing a shared pointer are separate operations. If that distinction does not land, nothing further will.

    Documentation for this step →
  2. 0220m

    Import a repository you actually care about

    DoRun the Git import against a real repository — ideally an awkward one, with merges and a rewritten branch or two.

    You should seeHistory present and addressable, with change identity assigned. Note anything the import declines to carry; that boundary is documented, and it is better to find it now.

    Documentation for this step →
  3. 0315m

    Protect a path with no server at all

    DoUse Tier-0 Solo to put a policy on a path and commit it.

    You should seeThe working copy still reads normally; the stored object does not. No Key Authority, no network. This is the cheapest way to see whether encrypt-at-snapshot is real.

    Documentation for this step →
  4. 0420m

    Issue a capability token and then break the rules

    DoIssue an agent token — the default excludes every policy-protected path — then deliberately have it commit to one of those paths and read a protected file it has no clearance for.

    You should seeRefusal before anything is sealed, with a coded error you can look up. An enforcement claim you have not tried to violate is not a result.

    Documentation for this step →
  5. 0515m

    Rewrite history and check what survived

    DoAmend, rebase, and squash a change, watching the commit ID and the change ID at each step.

    You should seeThe commit ID moves every time. The change ID does not. Review and provenance anchored to it are still attached at the end.

    Documentation for this step →
  6. 0645m

    Run a server and clone through it

    DoBring up `tovio serve` behind TLS and clone with a sparse path scope from a second machine. That half is Apache-2.0 and needs no agreement. Standing up the Forge instead — and with it the connection ACL, lane protection and review gating, which `tovio serve` does not enforce — needs the commercial agreement and the operator documentation that comes with it.

    You should seeA working networked round trip you configured yourself, with a protected path that stays encrypted on the far side.

    Documentation for this step →
  7. 0720m

    Go looking for the dealbreaker

    DoRead the threat model, specifically the accepted residual risks for v1, and the roadmap of open work.

    You should seeEither you find a residual risk your organisation cannot accept — in which case you have your answer cheaply — or you do not, and the rest of the evaluation is worth your time.

    Documentation for this step →

Reasons to walk away · as of 2026-08-03

If any of these is a hard requirement, the answer today is “not yet”.

Read from the same versioned status manifest the download and pricing pages use. Nothing here is softened for the sake of the evaluation.

You need signed, published binaries today

There are none. The publication gate is closed and building from source is the supported path.

You need a completed independent security audit before adoption

It has not happened yet. The specification is public and the claims are checkable, but a third-party report does not exist.

You need managed hosting rather than an operations team

The hosted service is not available yet. A production on-premise Forge is a commercial agreement; a source build under that licence remains the supported evaluation route.

You need attribute-based read control in production now

Tier-2 CP-ABE has passed its conformance and internal-review gate but stays behind private, default-off boundaries and is not currently available. Tier-1 recipient-based control is what you can evaluate today.

You need server-enforced exclusive locks on unmergeable assets

Lock grants are arbitrated between client and server, but no push or land path consults a lock store yet. Treat locking as coordination, not enforcement, until that changes.

You need counsel-approved commercial terms to sign

The legal text on this site is a prelaunch draft and is marked as such. It cannot form an agreement yet.

Ask us these

Questions we will answer with a document, not an adjective.

  • Which behaviours are implemented today versus specified but not yet built?
  • What exactly does the audit chain record on a protected read, and what does it not?
  • What happens to a capability token that is delegated, then the parent is revoked?
  • Where does the Git bridge lose fidelity, in both directions?
  • What are the declared scale ceilings, and what evidence exists at them today?

Start with the quickstart, finish with the threat model.