Decentralised News · 2027 planning series · Reviewed 21 November 2026
What Matters
An AI application can keep its large input files offchain while publishing a small commitment or verified result onchain. That can change the cost and trust model, but it does not make the files permanently available or make their contents true. The useful question is which bytes a contract must read, which statement it must verify, and which evidence someone must reconstruct later.
This guide separates four placement choices and provides a budget worksheet for their retained bytes, public payloads and declared costs. It does not rank storage tokens or claim that AI can bypass a network’s resource limits. Start with the required evidence and execution path; price the design after those requirements are explicit.
The Signal
The primary documentation draws several boundaries that marketing often merges. Ethereum describes data availability as the ability to obtain the data needed for verification. EIP-4844 exposes versioned blob hashes to execution while keeping the blob contents unavailable to direct EVM reads. IPFS distinguishes content identification from persistence. RISC Zero describes receipts as evidence about a particular program’s execution and public outputs. These are complementary mechanisms, with different jobs. Ethereum’s availability guide, the blob specification, IPFS persistence documentation and RISC Zero receipt guide establish those distinctions.
1. Define the decision before choosing the storage layer
Imagine a procurement contract that releases payment after an offchain model checks a supplier’s evidence package. Its designer needs to answer three different questions. Can the model process the package? Can the contract accept the claimed result under the chosen verification rules? Can an authorised reviewer later reproduce the decision from the retained package and software version? A design can satisfy the first two while failing the third.
Write a short acceptance statement before discussing providers: “For input commitment X, program version Y produced output Z under policy version P, and the required evidence remains reconstructable for R months.” Every component needs an owner and an evidence location. If the contract instead needs to inspect arbitrary original bytes during execution, a pointer alone does not meet that requirement. An application redesign or an execution-accessible representation is necessary.
DN’s approach treats placement as a contract between the application, its verifier and its future reviewer. A low storage quote is useful only after that contract is coherent. Otherwise a team can optimise a system that is unable to answer the very question its users will ask during a dispute.
2. Separate the four placement choices
| Placement | What it contributes | What remains to establish |
|---|---|---|
| Contract state or execution-accessible transaction data | Bytes available through the relevant execution path; state can hold values required by later calls. | Exact accessibility, capacity, fees, privacy and historical retrieval requirements. |
| Blob data with a commitment | A dedicated temporary data-publication path; execution can reference the specified commitment mechanism. | Application decoding, reconstruction and archive retention beyond the network’s applicable window. |
| Offchain object plus commitment | A compact identifier or digest linked to the application’s accepted object representation. | Who retains and serves the bytes, the verification procedure and the source’s authority. |
| Offchain computation plus proof | Evidence for an explicitly defined computation and accepted public statement. | Input provenance, program correctness, verifier assumptions and continued access to required evidence. |
The first row also contains distinctions. Solidity’s introduction to smart contracts describes state held at a contract address, while Ethereum’s data-storage strategies discusses storage, calldata, events and offchain approaches. A historical transaction is not the same thing as a value already available to a later contract call. Specify how a future verifier obtains each required byte rather than using “onchain” as a complete retrieval plan.
The table is a functional map, not a claim that all four approaches are interchangeable. A proof can accompany an object archive. A blob can carry data that another party also retains. A state commitment can identify an offchain file. The composition is what needs review.
3. Treat a commitment as a binding, not a storage subscription
A commitment helps bind a decision to a particular representation. The representation matters. IPFS’s CID documentation explains that content identifiers incorporate information about encoding and hashing, and that a file’s CID is not generally the same as a simple whole-file checksum. A team therefore needs more than a copied string: it needs the encoding procedure, object boundaries and verification method that the application actually accepts.
For the procurement example, choose whether the commitment covers one invoice, a bundle of attachments or a manifest referring to several objects. Record the package version and the mapping from that package to the model input. If preprocessing removes a page or changes a field, the original package and the processed input are separate artifacts. One commitment should not silently stand for both.
Availability is another obligation. IPFS explains that pinning protects data from garbage collection on the relevant nodes, while continued retention still depends on someone maintaining the storage arrangement. DN’s practical implication is to assign a funded retention obligation to the evidence package rather than treating its identifier as a guarantee that a future reviewer can retrieve it.
4. Budget for the retention period the application needs
Temporary availability and a multi-year evidence requirement are different time horizons. EIP-4844 expressly permits blob data to be removed after a relatively short period and makes the blob contents unavailable to direct EVM execution. An application using blobs should therefore identify its applicable network parameters and arrange any longer-lived archive separately. This article does not turn historical blob limits into a current capacity promise.
Choose retention from the application’s documented need. A trading simulation, a payment dispute and a scientific replication may require different materials and time periods. The relevant question is whether the full reconstruction path survives for that period: bytes, permissions, decryption access where applicable, software identifiers and the meaning of the original output.
There is also a billing question. Two configured replicas do not necessarily mean two separately billed copies, and two bills do not prove independent failure domains. The worksheet’s copy count is deliberately a cost multiplier. Technical independence needs its own evidence. Similarly, compression reduces billed bytes only if the quoted service bills that compressed representation and the recovery process retains the means to decode it.
5. Keep proof validity and source truth separate
RISC Zero’s documentation describes checking a receipt against the expected program image identifier and inspecting its public journal. That makes the chosen program and public statement central to the verification decision. A valid execution proof for a program that accepts unauthenticated invoices does not turn those invoices into genuine supplier records. That is a limitation of the statement being proved, not a reason to discard proofs.
In the procurement example, specify which claim belongs to which system. A supplier signature can identify an asserted sender under the chosen key policy. A computation proof can support an assertion about a reviewed transformation. A retained package can support later inspection. None of those components, alone, establishes that physical goods arrived or that the underlying commercial agreement was satisfied.
AI is also a component with an explicit role. It might classify documents, extract fields or produce a recommendation. Keep that role distinguishable from the program that verifies a proof or the policy that authorises payment. For deeper proof-statement analysis, use DN’s existing ZKML verification guide; this article focuses on where the bytes and reconstruction budget belong.
6. Calculate the mature retention budget
The worksheet uses a constant-inflow reference model. New retained GiB per month equals runs per month multiplied by unique retained MiB per run, divided by 1,024. Unique retained GiB at steady state equals that monthly inflow multiplied by retention months. The billed-copy multiplier and storage quote then produce the monthly storage charge once the rolling archive has filled.
Monthly retrieval cost is retrieved GiB multiplied by the retrieval quote. Publication and application-computation charges each equal runs multiplied by their respective per-run quote. The proof path adds a separately declared proof-generation charge. The total is the sum of those components. Use one currency and compatible binary units throughout: a decimal GB price needs conversion before it is entered as a GiB price.
The selected path changes the interpretation of the publication quote, so replace that quote when comparing designs. It may need to include multiple transactions, verification calls or blob fees. The worksheet does not discover a chain’s fee schedule, check transaction-size limits or prove that a proposed payload can be published. Every design retains the separately specified archive in the model; choosing raw publication does not silently erase that cost.
The public-payload field is an accounting observation, not a compression achievement. Enter the complete serialised execution input, result, commitment package or proof that your application would publish. A small digest next to a large proof must not be counted as though the digest were the entire payload. When all raw input must be supplied for execution, use the same byte-encoding basis for retained input and public payload; the payload must include at least those input bytes. The worksheet flags a smaller declared payload as a design mismatch.
DN Data Placement and Retention Budget
Change the illustrative assumptions below. This worksheet runs locally in your browser. It records your declarations; it does not verify evidence, connect to accounts, submit instructions or grant approval.
The initial numbers are synthetic. Unknown evidence remains unresolved. Downloads contain the values you enter; use aliases and avoid private or identifying information.
Worked example: a document-processing evidence archive
Consider a synthetic service processing 1,000 new packages each month. Each package creates 100 MiB of unique retained evidence and a declared 1 KiB public payload. The retention requirement is 12 months, with two separately billed copies. These are invented planning inputs, not measurements from a provider or a deployed contract.
The monthly inflow is 97.65625 GiB. After the rolling archive fills, it holds 1,171.875 GiB of unique evidence, or 2,343.75 GiB under the two-copy billing assumption. At an illustrative $0.02 per GiB-month, storage costs $46.875 monthly. Retrieving 200 GiB at $0.08 per GiB adds $16. The declared public payload is about 0.98 MiB per month, excluding any bytes the author has failed to include in that payload definition.
With publication and verification quoted at $0.15 per run and application computation at $0.20, the reference monthly total is $412.88 after rounding. Selecting the proof path and adding $0.50 of incremental proof generation per run raises it to $912.88, provided the other quotes genuinely remain applicable. Neither number is a live market price.
Now change retention to 24 months. Storage doubles to $93.75, while the same retrieval, publication and compute assumptions produce a $459.75 commitment-path total. A change to retention has not automatically doubled compute. This separation lets the team see which design obligation drives the bill.
The example remains unresolved until the required execution access, accepted statement and reconstruction evidence are reviewed. The worksheet displays that unresolved state even while showing the arithmetic. A lower numerical total cannot repair a missing raw-byte execution path or an archive that expires before the stated retention period.
7. Make the architecture decision reviewable
Prepare a short decision record containing the application purpose, required execution reads, public statement, object representation, retention period, reconstruction responsibility and dated quotes. Add one explicit condition that would invalidate the design: for example, a later policy may require inspection of an attachment that the current preprocessing discards.
Then assign a budget owner to each obligation. The application team may pay computation, the contract operator may pay publication, and an evidence custodian may pay retention. Splitting those invoices does not reduce total system cost. It can instead hide an unfunded dependency unless the decision record brings them together.
Keep confidentiality separate from integrity. IPFS’s privacy guidance explains that encrypting content affects access to its plaintext while traffic and content-publication considerations remain. DN’s design implication is to review whether material should be publicly distributed at all before budgeting for an encrypted public copy. A digest, proof or encrypted object is not an automatic permission to publish sensitive records.
Use DN’s storage-network comparison for AI archives for provider and lifecycle selection after placement is settled. This worksheet answers the earlier question: what must each layer retain, expose or prove, and what recurring budget follows from that choice?
Stress the assumptions before accepting the cheaper design
Run three further scenarios before taking a quote into an implementation review. First, double the retained input size while keeping public-payload size fixed. This isolates archive growth from publication charges. Second, increase retrieval to represent a concentrated review period rather than an average month. Third, change the publication quote and the proof-generation quote separately. Those changes reveal whether a claimed saving comes from the architecture or simply from an optimistic assumption.
A useful comparison also records what has been held constant. If one design keeps only extracted fields while another retains the full original package, their prices describe different evidence obligations. If one proof covers a reduced program, it may support a narrower claim. Label those differences before presenting a cost comparison to a decision maker.
Do not convert the worksheet into a savings percentage unless the compared designs satisfy the same acceptance statement and retention requirement. A more expensive design may preserve an essential review path. A cheaper design may be sufficient when the application genuinely needs less evidence. The review record should explain that choice in terms the application owner can challenge.
Methodology and limits
This is an original DN planning framework based on the linked protocol documentation, reviewed on 21 November 2026. The formulas are accounting identities applied to user-entered assumptions. No network benchmark, provider durability test, smart-contract execution, proof generation or fee sampling was performed for the example.
The steady-state model assumes constant monthly inflow, fixed-size new evidence, whole retention months and a stable number of billed copies. It does not model first-year archive growth, intra-month deletions, variable demand, retries, request-based charges, engineering, monitoring, incident recovery, taxes or currency changes. Add those costs to a separate implementation budget. A price of zero means a deliberate scenario assumption; a blank value is rejected.
The evidence selections record the user’s declarations. They do not authenticate a document, inspect a program, retrieve an object or approve deployment. Unknown evidence remains unknown, and a known mismatch produces a design-mismatch result. Treat the exported record as a dated review aid, with the underlying sources and operational evidence maintained elsewhere.
DN Alpha Thesis
The strongest data architecture assigns a precise job to each layer. Execution-accessible bytes support the reads a contract needs. Commitments bind accepted representations. Proofs support defined computation claims. Archives preserve the evidence required later. Economic value comes from removing unnecessary duplication while funding every remaining obligation, with a budget and review record that makes those obligations visible.
Sources and evidence register
Primary sources reviewed on 21 November 2026. The article distinguishes documented facts, DN analysis and synthetic examples. Recheck changeable rules and configurations before acting.
- Ethereum: Data availability — Availability for verification; not a general long-term archive guarantee.
- EIP-4844: Shard Blob Transactions — Blob commitment access, execution boundary and temporary retention design; historical parameters are not quoted as current limits.
- Ethereum: Blockchain data storage strategies — State, calldata, events and offchain placement distinctions.
- Solidity: Introduction to smart contracts — Contract state and the relevant execution context.
- IPFS: Content identifiers — CID representation, encoding and distinction from whole-file checksums.
- IPFS: Persistence, permanence and pinning — Pinning, garbage collection and continuing retention obligations.
- RISC Zero: Receipts 101 — Public journal and verification against the expected program image identifier.
- IPFS: Privacy and encryption best practices — Plaintext confidentiality and public-network considerations are separate.
Frequently asked questions
Does an onchain hash keep the original file available?
No. It can help bind an accepted representation, but someone still needs to retain and serve the original bytes. The retrieval and reconstruction obligation needs its own evidence and budget.
Can a smart contract read an IPFS file directly from its CID?
A CID alone does not make the file bytes available to contract execution. The application needs an explicit mechanism to supply or verify the required data or a precisely defined result.
Are Ethereum blobs a permanent AI archive?
The blob design provides temporary data availability and a commitment mechanism. An application with a longer retention requirement needs a separately supported archive and reconstruction plan.
Does a computation proof establish that the input was true?
It supports the exact computation statement accepted by its verifier. Input provenance, source truth and the real-world meaning of the output require additional evidence appropriate to the application.
Is the worksheet total a first-year cost estimate?
No. It is a mature rolling-retention monthly budget under constant inflow. It excludes startup archive growth and several operational charges listed in the methodology.
Why does the tool show a budget when evidence is unknown?
Arithmetic and design readiness are separate. The budget can be calculated from declared numbers while the status continues to show unresolved evidence or a known mismatch.




