Announcement · Hardware · Open source

Introducing TDCC Exact Core

An AI chip whose every answer anyone can re-check, and a Solana market to rent it.

View on GitHub Run the demo
EC-01Kintex-7 xc7k480tBuilt on openTPU
TDCC Exact Core · EC-01Illustration
TDCC Exact Core package with matrix unit, vector unit, trace log, and sequencer MATRIX · INT8 VECTOR TRACE SEQ · DMA
Exact Core, explodedIllustration
Determinism
Bit-exact

The card produces the same tokens as its simulator

Decode
85.8 tok/s

LFM2.5-230M decode on the card, 4-bit weights

Dispute
5 rounds

To find the one bad step out of 66,862 in a dispute

Overhead
+14%

Cost of the trace log on the simulator

Today we're releasing Exact Core, the accelerator behind TDCC Exact. It is built on openTPU, an open-source AI accelerator whose card gives the same bits as its simulator, and it adds what an auditable chip needs: a trace log of every instruction, a fingerprint a provider posts with each answer, and a dispute that names the first instruction a dishonest run got wrong.

The result is compute you don't have to trust. Anyone with a laptop can re-run a job and get the provider's exact answer, down to the last bit of the logits. If the provider cut corners, the mismatch shows, and the dispute points to the step where it happened.

01 · The problem

Why exact matters

When you buy compute from someone you don't know, you get an answer back and very little else. A provider can skip part of a model to save time and still return something plausible. Re-running the job elsewhere usually doesn't settle it: floating-point math drifts across hardware, so two honest runs rarely agree bit for bit.

Exact Core removes the drift. Matrix math runs in 8-bit integers in a fixed order, and softmax and norms use fixed rounding. Every honest run, on any machine, produces the same bits, so "did they actually run it?" becomes a question with a yes-or-no answer.

In the demoIn our demo, a cheating provider skips one layer and still returns the same Yes/No answer as the honest provider. Only the fingerprint differs. That is exactly the case a buyer cannot detect on a GPU marketplace today.

02 · Architecture

What's inside

Exact Core runs on a Kintex-7 FPGA PCIe card (Inspur YPCB-00338, xc7k480t, two DDR3 channels). The only change to the openTPU design is an observer hook that runs after every instruction.

Block01

Matrix unit

The heavy LLM math in 8-bit numbers, in a fixed order.

Block02

Vector unit

Softmax and norms with fixed rounding, so the bits never drift.

Block03

Trace log

Records every step, so a dispute points to the one step that differs.

Block04

Sequencer + DMA

One instruction per cycle; every data movement is an instruction.

The four blocks of Exact Core.

The trace log

Each instruction extends a SHA-256 hash chain over the slice, the program counter, the instruction, and the registers after it. Every 4,096 steps the log checkpoints each slice's working state. The checkpoints form a Merkle tree whose root is the trace root. We chose SHA-256 because Solana's runtime offers it as a syscall.

The fingerprint

With each answer the provider posts H(job ‖ model image ‖ answer ‖ last logits ‖ trace root). Two honest runs give the same fingerprint on any machine. The model image hash pins the exact weights and build, so a provider that quietly swaps 8-bit weights for 4-bit is rejected before anything is re-run.

03 · Measured on the card

Performance

The design runs ten modern models with their real weights on the card, and the card's tokens match the simulator's bit for bit.1

Decode throughput on the cardtok/s · higher is better
int84-bit, int8 head
LFM2.5-230M
59.0
85.8
Qwen3-0.6B
21.6
31.3
Qwen3.5-0.8B
17.6
24.5
Device decode rate on the Kintex-7 card. While decoding, the card uses 82–85% of its peak DRAM bandwidth.
Trace log overheads · lower is better
Log off
32.5 s
Log on
37.0 s · +14%

Verifiability is cheap. On the simulator, a 31-token prompt on LFM2.5-230M takes 37.0 seconds with the trace log on and 32.5 seconds with it off, and the logits are bit-identical either way.2

Seconds for a 31-token prompt.
ModelWeightsDecode, deviceDecode, wallPrefill, deviceDRAM while decoding
LFM2.5-230Mint859.052.3295.614.5 GB/s (85%)
LFM2.5-230M4-bit, int8 head85.882.1335.414.1 GB/s (82%)
Qwen3-0.6Bint821.621.392.114.4 GB/s (84%)
Qwen3-0.6B4-bit, int8 head31.330.7103.413.9 GB/s (82%)
Qwen3.5-0.8Bint817.616.361.414.5 GB/s (85%)
Qwen3.5-0.8B4-bit, int8 head24.523.366.714.1 GB/s (83%)
Throughput in tokens per second.

04 · The market

How TDCC Exact works

Compute runs off-chain. Money, proofs, and penalties live on Solana.

  1. Step01

    Rent

    A renter opens a job on Solana. The USDC waits in escrow.

  2. Step02

    Run

    A provider runs it on Exact Core and posts the answer's fingerprint.

  3. Step03

    Check

    Any verifier re-runs it on a laptop. A mismatch opens a challenge.

  4. Step04

    Settle

    Honest providers get paid. A cheater loses its stake.

When the work is accepted
80 / 20

80% of the price goes to the host and 20% to TDCC.

When a provider is caught
Slashed

The renter is refunded, the verifier gets half of the provider's stake, and TDCC keeps the rest.

Receipts you can stake money on

Honest runs share a fingerprint, so a provider could try to copy someone else's receipt without doing the work. Receipts are therefore posted by commit-reveal: first a hash that binds the provider's key and a salt, then the fingerprint, after the commit window has closed.

The dispute

Once a run goes wrong, its hash chain differs at every later checkpoint. A binary search finds the first bad checkpoint in log₂ rounds, then both sides replay that window step by step and the first differing record is the fault. On LFM2.5-230M, with a provider skipping one layer, the dispute names the fault in 5 rounds over 21 checkpoints: step 7,166 of 66,862.

The Anchor program holds the escrow and stakes, takes receipts by commit-reveal, and executes the transfers. Program ID HzpKeqHLg7Mmjh1JmGymef7Z7hf3JXhaagp6UgTSH24A.

05 · Ten seconds, no card

Try it

The demo runs on a laptop in about ten seconds using the built-in tiny model, with no card required. Provider A runs honestly; provider B skips layer 1 to save time.

tdcc-exact demoTerminal
$ pip install -e .
$ tdcc-exact demo

1. renter opens a yes/no oracle job on tiny, locks 2.00 USDC
2. provider A runs it honestly; provider B skips layer 1
   A: NO  3c85c23e…
   B: NO  5013c640…  (168 matrix multiplies skipped: same answer, other fingerprint)
3. a verifier re-runs the job on this laptop
   A: match    -> accept
   B: MISMATCH -> challenge
4. searching B's trace for the first instruction that went wrong
   bisection: checkpoint 0 of 3 differs (2 rounds), steps 1..1302
   first fault: step 659, slice 0, pc 11 (state)
5. settlement (the Solana program executes these transfers)
Run the same steps against a local validator or devnet with tdcc-exact demo --localnet; each step becomes a transaction with an Explorer link.

06 · Status

Limitations

We want to be precise about what is built today.

PieceStatus
Trace log, fingerprint, disputeWorkingon the bit-exact simulator, tested
Commit-reveal receipts, model registryDonetested
Solana programWorkingon a local validator, arbiter-decided challenges
Trace log in hardwareNot builtthe card has a performance trace, not this hash chain
On-chain bisection, challenge bondPlanned
The demo proves the work is verifiable, not that the model is right.Exact Core agrees with the fp32 reference on every test question, so the chip computes the model faithfully. But the 230M model answers Yes to everything with this prompt. A production oracle needs a larger model or a calibrated threshold.

07 · Upstream

Built on openTPU

openTPU lives in one small repository you can read end to end: the hardware design in SystemVerilog, the instruction set, a bit-exact simulator, a kernel language and its compiler, and the host software that drives a real PCIe card. Exact Core keeps upstream's command and package names so that upstream improvements merge in cleanly. We're grateful to its authors.

Open source · USDC escrow on Solana

Run it, read it, rent it.

The code is open on GitHub. Exact Core cards will appear as listings in the TDCC marketplace, paid through USDC escrow on Solana.

GitHub repository Open the marketplace

Notes

  1. Measured on an Inspur YPCB-00338 card (Xilinx Kintex-7 xc7k480t, two DDR3 channels), as documented in the openTPU results. ↩
  2. Simulator timing on a 4-core cloud VM, LFM2.5-230M int8. Logits with the log on and off were checked to be bit-identical. ↩