From a job to evidence you can reuse.
This is the full lifecycle of work on Scalar — what happens between an application submitting a job and the network delivering a validated result that future work can build on. Every diagram on this page is illustrative, and every stage is labeled honestly.
A job enters Scalar
An application submits work as a job contract — not a loose request, but a bounded description the network can act on and check against.
- Objective — what the job is trying to produce.
- Constraints — cost, latency, data-handling and security limits.
- Evidence requirements — what must be returned alongside the result.
- Assurance level — how much independent checking the job demands.
- Validation method — how acceptance will be decided.
A job contract becomes bounded, checkable work
Scalar decomposes the work
One job becomes many bounded work units. Decomposition is what makes the rest of the system possible.
- Parallelization — independent units run at the same time, across different machines.
- Security boundaries — no worker needs to see the whole job.
- Clear acceptance criteria — each unit knows what "done correctly" means.
- Independent validation — small units can be re-checked without re-running everything.
One job, split into bounded units, recomposed
Work is routed across the network
Units are assigned to workers by a coordination layer that weighs several factors at once — not just whoever is free.
- Capability — can this machine actually do this kind of work?
- Availability — is it free, and for how long?
- Security — does it meet the job's data-handling requirements?
- Cost & latency — what does this placement cost, in time and money?
- Reputation — what does its prior validated history say?
Routing across a controlled, tokenless testnet
Work returns with evidence
A result on its own is just a claim. Scalar jobs return a result plus the material needed to check it. Conceptually, that evidence package includes:
- The artifact — the output itself.
- Execution evidence — how the work was actually run.
- Source evidence — what inputs and references it relied on.
- Test results — the checks the worker ran against the acceptance criteria.
- A receipt — a record tying all of it to the job contract.
We describe this as evidence, not cryptographic proof: the stronger proving machinery is still in development, and we won't claim it before it exists.
Evidence lets a claim be compared against a re-derivation
Independent validation decides
Validators who did not do the work re-check it against the job contract. The field of validators can reach different states, and Scalar treats each one differently.
- Agreement — validators converge; the result is accepted.
- Dissent — a minority disagrees; their findings are recorded, not discarded.
- Outlier — a single validator diverges from an otherwise agreeing field.
- Multi-cluster dispute — validators split into camps; the work is escalated, not forced through.
- Quarantine — work that fails validation is isolated and withheld from memory.
Consensus does not imply objective truth. Agreement between validators is evidence about the work — not a guarantee that the result is correct.
Agreement, dissent, and outliers in one field
The Braid preserves what happened
Everything about the job — the contract, the work units, the evidence, the validation outcome — is woven into the Braid: three interleaving strands of record.
- Job strand — what was asked, under what contract.
- Work strand — what was done, where, and how.
- Validation strand — what was checked, and what was decided.
Once woven, the record supports resolution (what actually happened), becomes a durable Braid record, qualifies work for Cortex eligibility, and accompanies delivery back to the application. The Braid is a provenance fabric — not a blockchain.
Job, work and validation strands, woven — not chained
Cortex remembers accepted work
Cortex is Scalar's permission-aware memory. It does not absorb everything — only work that earned its place.
- Accepted work in — validated results become structured, reusable memory.
- Quarantined work outside — failed work is kept out of memory.
- Disputed work withheld — unresolved work is not treated as reusable.
Access is permission-aware: memory respects the rights and constraints attached to the original work.
Qualified evidence settling into memory · planned
The next job can use the history
This is the payoff. When a new requirement arrives, candidate artifacts from prior work appear — and each one is put through eight gates before anyone relies on it:
- Provenance — do we know exactly where it came from?
- Rights — are we allowed to reuse it?
- Quality — did it pass validation, and how strongly?
- Security — does it meet this job's handling requirements?
- Compatibility — does it fit the new context?
- Applicability — does it actually answer the new requirement?
- Validation — can its evidence be re-checked now?
- Adaptation cost — is reusing it cheaper than redoing it?
Prior evidence where it qualifies, new work where it doesn't
Scalar does not reuse history because it exists.
It reuses history because that history was bounded, evidenced, independently validated, and preserved with its provenance intact — and because it passes the gates again, every time. Reuse is earned, never assumed. Savings and reuse are not guaranteed.