Skip to main content
A screenshot of a real device in use can contain anything that was on that screen: a signed in app, a message, a personal detail. Frames are therefore treated as the most sensitive thing the control plane touches.

The default archive policy has no automatic expiry

Archiving requires configured frame storage on the deployment. When storage is configured, the default policy enables archiving and keeps frames with no expiry time. An organisation with an explicit policy keeps its own setting. The service does not automatically delete persisted frame bytes. Its background loop reconciles unconfirmed writes and reports storage usage; it does not remove an archived image. Do not assume that returning a device, deleting a chat thread or closing an account erases a separately archived frame.

Read one available frame

GET /v1/frames/{frameId} returns a short-lived signed URL for one archived image. Obtain the frame id from a run’s lastFrame.frameId or an action receipt’s observedFrame, then call the route with your bearer credential. The credential needs devices:read or permission to run tasks, and any device restriction on the credential applies to the frame too. An unknown frame, another organisation’s frame, an unconfirmed write, an expired frame or a frame outside the credential’s devices all return 404 frame_not_found. A deployment without frame storage returns that answer for every frame id. A live screenshot can still be available even when no archived copy exists. The former run-frames and receipt-frame endpoints have been withdrawn. Use the current single-frame route rather than those old paths.

The store is private, and a read uses a URL we mint

The store is private in its own right: an anonymous request, a request carrying the public API key, and a request from a signed in browser session are all refused, including the request that only asks whether an object exists. The route returns a signed URL for one image rather than pixels. Its normal lifetime is one minute, with a signer cap of five minutes; a finite frame expiry can shorten it. The response contains frameId and url, not a TTL field. Treat the URL as a password for that one image while it lasts: do not store it, log it, or paste it into a bug report. Fetch a new URL when you need to view the image again. Before any URL is signed, the frame is looked up in the database under your organisation’s own row level policy, and the storage location is read out of that row. It is never constructed from the values in a request. That distinction is the authorisation: a location built from arguments would be a valid looking location for somebody else’s frame, and object storage has no idea which tenant asked.

What we do not do to a frame

Frames are not encrypted at the application layer, and the reason is worth being straight about rather than implying more protection than exists. The protection is the private bucket, a credential whose reach is object storage and not the database, the organisation check above, and the short lived URL. There is no per organisation key, and per frame crypto shredding is not available today.

Turning archiving off

An organisation can be taken out of frame archiving entirely, and can instead choose a finite retention window with a ceiling of 90 days. Both are set through the operational management path, not by you and not by an agent; ask if you want either. Two things about those settings:
  • Leaving the archive does not erase what is already in it. It stops new frames being written.
  • A zero day window means the bytes are never written, not written and then cleaned up shortly after. At that setting the control plane records that a frame was captured and stores no image, so there is nothing waiting on a cleanup process to run on time.
An organisation on a finite window has frames that stop being readable through new API requests when that window passes. The database gate enforces this. A finite expiry can shorten a signed URL’s lifetime, but signing uses whole seconds with a one-second minimum: an existing URL is not guaranteed to stop working at the exact expiry instant. Expiry of API access is not deletion of the stored bytes. Ask about existing archive data when arranging a retention change or deletion request.

Retention is decoupled from billing, permanently

Frame bytes do not participate in billing, usage or quota, and never have. The billing pipeline derives from the receipt ledger, which contains no frames. This is not a coincidence maintained by care. The two read and write completely disjoint paths, and that is checked directly: billing derived with frame data present and billing derived with it gone produce identical results. The consequence that matters to you: what happens to your frames can never cost you a billing record, so “we need it for billing” can never become an argument about images.

What the control plane keeps besides the image

A frame’s identity is tracked separately from its bytes, and was long before the bytes were stored:
  • the frame id you can echo back as observedFrame,
  • a per device sequence number,
  • when it was registered, and the geometry it was captured at.
That is what makes it possible to refuse an action decided on a screen that has already changed. The receipt ledger holds no frame bytes. screenshot is not one of the actions a receipt records, and the summaries that are recorded are deliberately thin: a typed string is recorded as its length, never its content.

An agent cannot configure its own retention

Retention configuration is not an MCP tool, and this is a structural decision rather than a backlog item. An agent that could shorten its own audit retention could erase the record of what it did. That defeats the purpose of having a record. So the configuration surface is not reachable from the tool surface at all: it is written through the operational management path, under the same org pinning and row level policies as everything else. Cross org access to that configuration is blocked by the same two independent guards described in Org isolation, and the absence of a configuration tool on the MCP surface is checked rather than assumed.

In a private deployment

Where the part that reaches your devices runs in your own environment, frames never leave it. The same schema travels with it, and you hold the storage. PhoneUse does not reach into your environment to read or remove your data, in the same way it does not reach in to meter it. That deployment shape is a seam that is kept clean, not a product you can buy today.