The bytes persist. The bucket disappears.
The object primitive of the estate: artifacts that outlive the process that produced them, named once and served everywhere — behind a front door that serves today, with every gate to the rest stated in the open.
Every unit of work ends by producing bytes: a report, an upload, a model, a build output, a recording, a generated page. The object is the plainest unit in computing — named bytes, kept whole, served on request — and the default offer for keeping one is a bucket plus a profession: a region to place, storage classes to tier, lifecycle rules to choreograph, access policies to debug at midnight, presigned URLs to mint and expire, a CDN to wire in front because the bucket alone is slow from anywhere that matters, replication to design, and an egress line that prices leaving. The serverless wave reached blobs first — no instance to size, and there never was one — and stopped at the disk: the bucket abstracted the hardware, not the operations. The file took a millisecond to produce; serving it is apparently an architecture.
The tax lands hardest exactly where the estate's whole premise lives: on builders and businesses too small to carry a storage practice. A primitive you must operate is not a primitive. If artifacts are what the machine economy hands itself — what functions emit, workflows pass between steps, and agents produce for their principals — then keeping bytes has to be sold at the unit of the object, or the plainest layer in the stack keeps carrying the most operations per byte.
One data layer, two doors, and the seam between them is a rule, not a mood. Queried by field → the record grain: database.do, where a declared schema types every row and callers ask questions of the data. Fetched whole by name → the object grain: this door, where the bytes are opaque, the name is the address, and the artifact is served exactly as it was put. The edge cases route by the same rule in both directions: metadata about an object — who put it, when, what it belongs to — is record-shaped and belongs to the sibling; the bytes it describes belong here. A record's large attachment is object-grain and lives here; the row that points to it stays there. Neither door poaches the other's grain, and both records state the rule so the boundary survives its authors.
This is deliberately not a fourth substrate property. Three things in this estate are the substrate itself — the studio, the platform, and the runtime — and storage.do is a primitive under them: the object half of the data layer the platform operates, wearing its own door because the builder who arrives holding artifacts is a different ICP from the business with an infrastructure decision, and a brand here is one ICP and one motion. In the estate's own registry the coordinate is exact: noun Storage, verb store, type primitive — filed at priority P1, status planned, a filing this record reports at face value on the bindings slide rather than editing the books from a deck.
// the intended contract — stated as design, not as a live warranty
const store = await storage('assets') // a store, held by name
await store.put('q3-report.pdf', bytes) // an object, kept whole
await store.get('q3-report.pdf') // served where the caller runs
There is nothing else to configure. The design — stated here as intent with its public gate below, not as a live self-serve promise: the name is the whole artifact's address, the put is the whole write path, and the substrate carries what a storage practice used to — placement, replication, durability, lifecycle, delivery. The live front door itself positions further reach — record-grain queries and consistency guarantees, spoken in database language — and this record treats that as the door's stated ambition at the wrong grain: record-shaped work routes to the sibling by the rule on the previous slide, and every capability posts only when the self-serve loop below can demonstrate it.
The public self-serve loop — sign up, name a store, put an object, fetch it served — is not yet the thing this record can post. The live page headlines global latency and scale figures; this record does not adopt them, or any durability, consistency, or performance figure, until benchmarks publish with their method and window. Capability claims post behind this gate.
Concreteness over adjectives: each door below was checked cold on 2026-07-30, re-verified 2026-07-31, and carries its own state and its own evidence URL — never one URL evidencing several domains. Serving is a liveness fact, not a tenancy claim: nothing here asserts external tenancy, metered billing in production, or a usage roll. Those publish behind their own gates.
storage.do serves. The front door a builder would resolve is live under
the "Storage.do" wordmark. (Its copy currently sells record-grain storage
in database language — a positioning seam against the registry's and the
gateway's own "Object Storage" filing, stated openly on the bindings
slide rather than smoothed over.)
The gateway routes this primitive as a named service today: GET https://apis.do/storage returns a machine-readable JSON record — no
login, no signup — naming the service, its domain storage.do, its
description "Object Storage", its category infrastructure, and its
status available.
platform.do serves — the operator's front door, whose own record files
this layer's siblings among its composed runtimes under the same claim
discipline.
database.do serves — the record-grain companion whose own converged
record draws the same grain boundary from its side.
functions.do serves — the execution sibling: the compute whose outputs
are the artifacts this layer exists to keep.
workflows.do serves — the orchestration sibling: the runtime whose
steps emit and consume artifacts held here.
agents.do serves — the runtime whose agents are the machine writers and
readers this primitive is built to answer.
The ambers, worn in the open — each the exact distance between what serves and what this door intends to be. One runs the unusual direction: the estate's own books lag its live door.
The domain's own machine door answers today — with the wrong voice:
storage.do/api returns 200 and an HTML page wearing the APIs.do
sibling's title, a catch-all render of the gateway's marketing surface
rather than a machine envelope — at the very address the gateway's
service record lists as this service's API. A machine that resolves this
primitive finds a door that answers and does not speak its language. The
claim flips when a structured catalog serves at that address.
The domain registry still files storage.do at status planned, priority P1 — filed before the door lit, and not yet updated to match the live surface. The record reports the books at face value in both directions: the door is posted above with its evidence, and the filing is reported here as it stands until the registry flips.
The registry carries a twin: objects.do — same category, same
subcategory, noun Object, description "Object storage" — filed as its
own P1 coordinate, and the name does not resolve today (DNS returns no
address, checked cold 2026-07-30, re-checked 2026-07-31). One function, two filings, one live
door: the database.do / databases.do seam class. Reconcile the
coordinates or distinguish the grains; non-blocking, because the green
claim above asserts only that this door serves, which stays curl-true
either way.
The live apex sells this door in database language — "how does it compare to traditional databases", consistency guarantees, records, migration from an existing database — while the registry row and the gateway's own service record both file it as Object Storage, and the record-grain door it describes already exists one coordinate over at database.do. The surface is ahead of the filing and at the wrong grain; this record adopts the filing, routes record-shaped work by the rule on the grain slide, and wears the difference here rather than inheriting the apex's claims.
Primary motion is B2D: the buyer is a developer who evaluates in the
docs and converts at the first stored-and-served object — no sales
motion, no demo call, no procurement. The evaluation surface is the
product surface, which is why the self-serve gate on the contract slide
is the deck's most important amber. Secondary is B2A: artifacts are
what agents produce and hand each other, and the first step of that
motion already serves, because the gateway returns this service's
machine-readable record, status available, to a caller with no login.
Purchase and settlement for the machine motion gate on the contract
surface, exactly as the sibling records state for theirs.
Layer-1 economics at the artifact grain: fixed cost is the shared substrate — placement, replication, durability, the operations practice run once for everyone; each additional store is a namespace on it, so blended margin improves with density while the metered model follows the bytes held and the operations served.
Kept bytes are the most honest marginal cost in computing: bytes held are bytes paid for, which is exactly why the metered model fits — the substrate's operations practice is a fixed cost amortized across every tenant, and the variable cost tracks the artifacts themselves. What the builder stops paying for is the part that never belonged to their bytes: the standing plumbing and the practice of tending it. The incumbent's remaining lever — pricing the exit through egress — is a posture this record neither copies nor promises against in prose: exit economics post with the rate card, where they bind. And there is no regulatory floor anywhere in this function: nothing in keeping and serving a byte reserves a step for a statutory person, so the implementation mix migrates all the way to Code.
Metered on state — bytes held and operations served — is the intended model, and the rate card IS the pricing surface: it binds when it posts at the contract surface — verbs, protocol, rate card, guarantees, including the egress posture — not before, and never as prose in a deck. No figure is published or implied until then.
Store counts, bytes held, request volumes, and the internal-versus- external split are gated. Each figure publishes with its window and base or it does not publish.
every brand the estate launches emits artifacts from its first day and keeps them on the estate stack this primitive anchors — demand generated by the portfolio’s own search process, structural before commercial; the usage roll publishes behind its stack#1 §A5 gate or not at all
the estate’s gateway already routes /storage as a named service, status available, to a machine with no login — when the reader is an agent, being discoverable and callable IS the distribution channel
moving compute is a redeploy; moving an archive is a transfer project the incumbent prices by the byte on the way out — a structural pull this record declines to dress up as lock-in: the tenancy this layer earns is the integration around the artifacts, and it holds only as long as the contract stays worth staying for
functions, workflows, records, and objects are composed runtimes under one operator and, when it posts, one contract — unbundling the primitive re-creates the plumbing the builder came here to delete
Serving is a liveness fact, not a tenancy claim: each posted URL below evidences that one door resolves — not that anyone occupies it.
storage.do serves — the primitive's front door is live.
apis.do/storage serves machine-readable JSON — the gateway's service
record for this primitive resolves for a machine with no login, status
available, description "Object Storage".
platform.do serves — the operator of the composed runtimes is live.
database.do serves — the record-grain companion is live.
functions.do serves — the execution sibling is live.
workflows.do serves — the orchestration sibling is live.
agents.do serves — the sibling runtime is live.
The domain's own machine door — answering today in the gateway sibling's HTML voice — is the next gate, and the most important one for the B2A leg: an artifact an agent cannot fetch is a promise, and this deck declines to make it in present tense.
The domain registry's own filing — planned, P1 — lags the live door; the record wears the lag rather than editing the books from a deck.
The registry's twin object-storage coordinate, whose name does not resolve today, is queued for reconciliation — stated here in the open.
The apex speaks in the sibling's grain; the registry and the gateway file this door's. The record adopts the filing and wears the difference.
The public self-serve loop and every durability, consistency, and performance figure gate together — benchmarks publish with their method and window, or not at all.
No figure is published or implied — including the egress posture — until the card posts where it binds.
The front door is storage.do — it serves today.
If this was forwarded to you: storage.do is the object primitive of the startups.studio estate's infrastructure layer — the blob companion of database.do in the data grain: records are queried by field there; bytes are fetched whole by name here, and both records draw that boundary by rule. It is deliberately not one of the estate's three substrate properties, and its deck says so; it is a primitive under them, sold to the builder who has bytes to keep and refuses to hire a storage practice to keep them. What is live is posted with a URL checked cold; what is not is pending with the gate that flips it — including the ambers it wears openly: the machine door that answers in the wrong voice, the registry filing that still lags this live door, the twin coordinate awaiting reconciliation, the apex copy that overreaches its grain, and the self-serve path with its benchmarks. Judge it by what is posted, and by how plainly it labels what is not.