Getting data in

Every asset records where it came from, and the detail drawer shows that origin. The route also decides where the bytes end up and whether they are billed.

Route	Bytes land in	Who can start it
Web upload	Managed storage	Workspace admin / billing
Pod harvest	Managed storage	Automatic, from a running Pod
Task output	Wherever the task wrote — managed or your bucket	Automatic, when the task ends
Hugging Face / CivitAI import	Managed storage	Workspace admin / billing
Register from your bucket	Stays in your bucket	Workspace admin / billing

Web upload

Upload in Assets takes individual files or a whole folder (folder structure is preserved as each file’s relative path). Files go straight from your browser to storage — they do not pass through our API servers.

Limit	Value
Max size per file	500 GiB
Max files per version	1000
Upload window	24 hours of inactivity — it renews while the upload is making progress

• Oversized files are rejected before any bytes move. The size check happens when you pick the files, not hours into the transfer.
• Large files are split automatically. Anything over ~200 MB uploads in parts, in parallel. You don’t configure this.
• A slow connection is fine — there is no deadline. The window measures how long a session sits idle, not how long the upload takes; it renews as long as parts keep moving. A 500 GiB upload that runs for days is a supported case. What the window is there for is cleaning up sessions that were abandoned: stop for a full day and the session is discarded, and you start over.
• A checksum is computed in your browser before the bytes go out, and the server verifies the stored size on completion.
• You can leave the page. The upload keeps running while you navigate the console. Closing the tab stops it.
• Resuming. If an upload is interrupted, the Assets page offers to resume it — reselect the same file and only the missing parts are sent. Resume works in the browser that started the upload, and while the session is still alive. After that, start over.
• Retrying a failed upload appends to the same asset instead of creating a duplicate series.

Note

The file name, size, and type are fixed once an upload starts. To change them, cancel and start again.

Pod harvest

A Pod can write files and have them become assets on their own — no upload step, no SDK call.

How it works. The Pod’s template declares semantic paths: a role plus a directory.

Role	Meaning
output	Harvested — everything written here becomes an asset
config	Harvested — configs and recipes alongside the outputs
dataset, lora, model	Placement targets — where attached assets are mounted
checkpoint, diffusion_model, vae, text_encoder, controlnet, embedding, upscale_model	Finer-grained placement targets, one per model kind (used by the ComfyUI templates)
model_cache	Recommended volume location; never force-mounted, so it can’t shadow content baked into the image

Official templates ship with declarations. For your own templates, add them under Semantic Paths in the template form.

Inside the container the declared directories are exposed as environment variables (MESHIVE_OUTPUT_DIR, MESHIVE_DATASET_DIR, …), so scripts don’t hardcode paths. A Pod with no declaration still gets /outputs.

What gets harvested.

• The unit is a top-level entry under the directory: a file becomes one asset, a directory becomes one asset containing the whole tree.
• A background agent watches for entries that have stopped changing, then uploads them. Files still being written are not picked up mid-write.
• Re-harvesting the same entry from the same Pod creates the next version; unchanged content is skipped, so an idle Pod uploads nothing.
• Include rules — each harvested path can carry comma-separated glob patterns (e.g. *.safetensors, images/). When set, only matching files are collected; when empty, everything is. Templates define them per path under Semantic Paths, and each Pod can override them from its asset settings. Empty files and Meshive’s own bookkeeping directory are always skipped.
• Files Meshive put there are skipped — a bundled ComfyUI workflow is not your work until you change it, so it stays out of your asset list. Edit it and the edited version is harvested normally.
• Deleting an asset is one-way. The agent will not recreate what you deleted, and deleting a file inside the Pod does not delete the asset.

Limits. A harvested entry goes through the same upload path as a web upload, so the same ceilings apply.

Limit	Value
Max size per file	500 GiB
Max files in one entry	1000

An entry over either limit is reported as an error on that entry and left where it is — nothing is silently truncated, and the rest of the directory keeps harvesting normally. Split the folder, or pack it into a single archive file, and it goes through.

Caution

Pods with a harvest role always get storage for it — a small volume is provisioned with the Pod and grows automatically as outputs pile up. It is billed like any other local volume (Pricing) and it disappears with the Pod, so anything you want to keep must have been harvested.

Task output

Everything a task writes to /outputs becomes an asset when the run finishes.

• The series is the task — re-running the same task adds a new version.
• The bytes are not moved or re-uploaded; the existing objects are adopted.
• Task outputs are never auto-deleted. They are ordinary assets from that point on, and are billed as storage if they live in managed storage.
• Which bucket a task writes to is set in the submit form, defaulting to the workspace’s connected bucket if you have one.

Import from Hugging Face or CivitAI

Import ▾ in Assets pulls a model straight into your workspace — no local download, no re-upload. Choose From Hugging Face or From CivitAI.

	Hugging Face	CivitAI
What you provide	Repository id and optional revision	Model version page URL (or its id)
Access token	A workspace-connected access token — connected once under Settings → Integrations and referenced by id, never typed into the import form	Your own CivitAI API key, entered on the import form for that run and used only for it
Gated / restricted content	The import runs with your token, so your access and the source’s licence terms apply	The import runs with your API key, within CivitAI’s rate limits, so your access and each model’s licence terms apply

• The copy is yours: each workspace gets its own copy, billed as managed storage. There is no shared cache between workspaces.
• Every file is checksummed on arrival, and the reported size is verified against the actual download.
• Progress is shown on the asset row; a failure shows the reason and offers a retry that appends to the same series.
• Large imports take a while — hundreds of GB of weights are copied at network speed. You can close the console; the transfer continues.

Caution

You are responsible for the licence and terms of anything you import — including gated repositories, non-commercial licences, each model’s own licence, and adult/NSFW content restrictions. Imports run with your credentials for the source; don’t import content you aren’t entitled to. See Terms §17 and §10.

Register from your own bucket

If the data is already in your S3-compatible bucket, you don’t have to copy it.

Import ▾ → From my bucket opens a browser over the credentials connected in Settings → Integrations (AWS S3, Cloudflare R2, MinIO, GCS). Pick objects and register them.

• No copy is made. The asset points at your objects where they already are.
• No storage charge from us — the bytes are in your account, not ours.
• We never delete from your bucket. Deleting the asset removes our record of it; the objects stay. That also means the asset breaks if you move or delete the objects yourself.
• Sizes come from your bucket at registration time. Checksums are not computed, so integrity verification is skipped for these assets.
• Browsing is rate-limited and paginated (a couple of hundred keys per page) to keep list costs on your bucket predictable.

Register a whole folder as a reference

Beyond individual objects, the bucket browser can register a folder as a reference asset — one asset standing for an entire prefix. Useful when the prefix is far too large to copy anywhere.

• Nothing is duplicated and nothing is billed.
• The object count and total size are a one-time snapshot taken at registration. If the listing is too large to walk completely, the asset shows Size unknown rather than a misleading number, and the object count is hidden with it.
• The asset carries a reference badge and shows the prefix it points at, instead of a file list.

Fetch a subset of a reference

Because nothing was copied, a reference asset can’t be mounted, injected, or downloaded directly. Instead you copy out the part you actually need: open the asset and use Fetch subset.

The modal offers two ways to choose:

• Patterns — include and exclude glob patterns, matched against the paths inside the prefix (one per line or comma-separated). A live preview shows how many objects match, their total size, and a sample of the matched paths.
• Browse — walk the folders inside the prefix and tick individual files.

Name the result and pick its type, and the selection is copied into managed storage as a normal asset version — mountable in Pods, usable in tasks, billed as managed storage. The reference asset itself is unchanged.

Per-fetch limit	Value
Objects in one fetch	500
Total size in one fetch	200 GiB
Single file in a fetch	80 GiB

A selection over these limits is rejected, not silently truncated — a partial copy that looks complete is the worse outcome. Fetching requires workspace admin or billing rights, and is locked while your balance is depleted (details).