> Source: https://upvera.tech/value/
> Upvera Value Engine computes Upvera Value, a unitless reading of a startup's verified work, the same way on every machine and with a receipt for every change.

UTR-26-02 · System report · Live · value@1

# Upvera Value Engine

Upvera Value Engine computes Upvera Value, a unitless reading of a startup's verified work, the same way on every machine and with a receipt for every change.

## Summary

Value Engine 3.0 is a pure function. Give it the events up to a moment and a rule version, and it returns one number. The same events and the same rule always give the same number, on any machine.

That number is Upvera Value: computed by Upvera, unitless, and built only from verified work, the response of real people, proof from owned sources and the wings a startup has earned. It orders startups in Ranks by the work. It is not a price, and it is not what a company is worth.

Every change comes with a receipt. The receipt lists its reasons line by line, and the lines add up to the change exactly.

## A ruler, not a price

Upvera Value is logarithmic. A new startup with no proof reads 100, and every additional 100 means twice the proven size: 200 is twice, 300 four times, 400 eight times. The first proof moves a lot; repeating the same amount moves less.

Four masses feed it, each through its own logarithm:

-   **Work**, 35 percent: posts the community responded to and verified shipping. A post without a response doesn't raise value.
-   **People**, 30 percent: independent people engaging with the startup, weighted by trust. The team and its inner circle count as one; the owner and bots don't count.
-   **Proof**, 17 percent: verified sources, from the [Proof Engine](/proof/), reaching full effect over 14 days.
-   **Wings**, 18 percent: the UPV in wings, weighted by trust and maturing over 72 hours. The owner's own wing doesn't count.

Evidence fades with a 180-day half-life, so a startup holds its value by continuing to build; without events, value doesn't rise on its own. Momentum compares the last 30 days with the startup's own 180-day pace, within ±50. An integrity deduction can only subtract, at most 50. The value people see approaches its new target with a six-hour half-life instead of jumping.

This is the full extent of what is public about the formula, and it is the same text Upvera shows in the app. The complete published method lives in the [value guide](https://app.upvera.co/value/guide).

## Same inputs, same number

Determinism is a property of how the engine is built, not a promise about how it is run.

-   The engine reads no clock and uses no randomness. Its output depends only on the events up to a moment and the rule version, not on the order they were written in.
-   All arithmetic is integer fixed point. Floating point, which can differ between processors, is rejected by a lint that runs on every build.
-   The engine is written in Rust. Its WebAssembly build, which Upvera's servers run, and a native build of the same code must produce the same bytes on a shared set of golden vectors, checked on every build.
-   Outputs are serialized as canonical JSON and hashed, so equality is a comparison of digests.
-   Runs are sharded per startup, on an hourly grid and on events. Resuming from a checkpoint gives byte-identical results to replaying from the beginning.

Each compiled build is content-addressed. The rule registry records which build a rule runs on, so the engine behind every number is named by its fingerprint.

## Receipts that add up

A real receipt, served by the public Value API for Upvera's own startup. Captured 2026-10-22 12:01 UTC.

**Fig. 1.** A live receipt from the public Value API: Upvera's own startup over 24 hours. Rows are reason codes in whole millionths; the four largest are shown and the rest are folded into “Other”. Press Recompute to fetch it again and add the rows in your browser.

A receipt telescopes: each row is a reason code, the mass it belongs to and an integer amount, and the rows sum to the change itself. Clients never compute amounts or percentages; they draw what the server returns. When two surfaces show the same fact, they show the same number, and a check in the build fails if they don't.

## Shadow first

A new rule never goes live cold. It runs as a `value.shadow` version beside the live rule, on the same events, and every shadow run is recorded. Shadow results are never shown per startup, so nobody can act early on a value under a rule that doesn't exist yet.

At the switch, the total value of all wings is preserved, and lending and folding on a startup wait until its value under the new rule exists. Value Engine 3.0 went live on October 18, 2026 as `value@1`, after its shadow run. Its successor is in shadow now as `value.shadow@3`. The full method is written up in [UTR-26-06](/research/rules-released-like-software/).

## By the numbers

**2**builds of the same code, WebAssembly and native, that must produce identical bytesValue Engine 3.0

**0**floating-point operations in the engineInteger fixed point, enforced on every build

**10⁻⁶**the unit of a receipt row, so rows add up to the change exactlyValue receipts

**1 h**grid on which values are published[Value API v1](https://upvera.dev/api/)

## Published and private

Published

-   The ruler, the four masses, their weights and time constants
-   Every receipt, with reason codes that add up to the change
-   The rule version and the build fingerprint behind every number
-   Index series, with method changes cut out as breaks

Kept private, on purpose

-   Calibration constants and trust factors beyond the guide
-   The signals that trigger an integrity deduction
-   The engine's source code
-   Per-startup results under a rule that is still in shadow

## Status and releases

`value@1` has been live since October 18, 2026 at 08:52:42 UTC. Values, receipts and indices are readable on [app.upvera.co/value](https://app.upvera.co/value) and over the [Value API](https://upvera.dev/api/).

1.  [2026-10-20**Value API v1**Read Upvera Value, receipts and indices over a public API. Nothing in it is a quote or an offer.Live](https://upvera.dev/api/)
2.  [2026-10-18**Index families**Category indices beside the Upvera Index. A method change is cut out of the series as a break, never smoothed over.Live](/value/)
3.  2026-10-18 09:31**value.shadow@3**The next candidate enters shadow beside value@1.In shadow
    
4.  [2026-10-18 08:52**Value Engine 3.0**The deterministic engine becomes the live rule after its shadow run.Live](/releases/value-engine-3/)
5.  2026-10-18 08:52**value@1**Value Engine 3.0 goes live.Live
    
6.  [2026-10-17**Value explorer and badge**Upvera Value curves with real post markers on app.upvera.co, and a badge any site can embed.Live](https://app.upvera.co/value)
7.  2026-10-17 14:12**value.shadow@2**The first calibrated candidate enters shadow.In shadow
    
8.  [2026-10-14**Value receipts**Every change in Upvera Value comes with its reasons, line by line, and the lines add up to the change.Live](/value/)
9.  2026-10-11 14:42**value.shadow@1**Value Engine 3.0 starts in shadow.In shadow
    

## Questions

### Is Upvera Value a price?

No. It is computed by Upvera and unitless. It is not a price and not what a company is worth. Nothing in the Value API is a quote or an offer.

### Can I recompute a startup's value myself?

No. The engine's source is private. What you can check is that every receipt adds up, that every number names its rule and build, and that the record behind it is sealed in a public day root.

### Is lending a wing an investment?

No. A wing is not an investment. UPV stays inside Upvera and can't be cashed out. No money goes to the startup when you lend a wing.

### Can a plan buy a higher place in Ranks?

No. Visibility can't be bought on any plan. Ranks orders startups by the work.

[Next · UTR-26-03**Upvera Day Roots**](/roots/)