Connect, run, govern
How-to guides for connect0 — bring your data into the core, run your agents on it, and govern every access from one place. Ask a question, or browse by category.
- Run
Run one agent across your repo and your database
One agent, two connected sources. Mount a GitHub repo and a Postgres database into the same project workspace, then let any MCP agent read both with `sh` to reconcile schema drift in a single run.
- Govern
Govern what your agents can reach
Three governance guarantees that ship today in connect0 — default-closed agents with ACL enforced on the MCP connector path, an audit trail on every action, and spend caps that stop a run before it overspends.
- Connect
Connect a data source to the core
Plug a GitHub repo or a Postgres database into connect0 so your agent can read it — one connector, materialised into the project workspace.
- Run
Run Claude Code on your connect0 core
Three commands to point Claude Code at your connect0 core and let it run shell commands on your connected data, in an isolated per-project sandbox.
- Govern
Workspace storage + R2 costs, metered per project
How much you can stash in `/workspace`, what Cloudflare charges for it, and how the core meters storage per project so the bill is always traceable to a source.
- Connect
Why pre-signed URLs and not a proxy
The design decision behind the upload surface — zero connect0 bandwidth in the data path, capability bound by SigV4 + expiry. The cost / latency / trust tradeoffs.
- Connect
Tiny configs, no curl — `upload.write`
When the agent already has the bytes in hand, skip the pre-signed dance. `upload.write` PUTs inline content up to 1 MiB directly.
- Connect
Connect a video, get a transcript back
Connect multi-hundred-MB media into the core — the curl flow, and what your agent does with the bytes once they're in.
- Connect
Connect a dataset once, iterate on it forever
Connect a file into the core once, then have your agent run analyses against it repeatedly. Use `info` to keep the agent oriented across turns.
- Connect
Connect a whole directory tree as a tarball
Connect a multi-file archive into the core and have your agent unpack it via `sh`. A worked example with the exact path-canonicalisation rules.
- Connect
What `recent_uploads.status` means
The pending → claimed → expired / oversize state machine on every upload link. Sourced from R2 events, not the client.
- Connect
Connect a screenshot for your agent to analyze
Connect an image into the core — browser drag-drop, the agent reads it via `sh`, and the failure modes when content-type doesn't match.
- Connect
Upload links don't survive expiry
Pre-signed PUT URLs are short-lived by design. Here's why, how long you get, and what to do when "the link expired" happens.
- Connect
What an upload link can and can't do
A precise inventory of what a pre-signed `upload.create_link` URL grants — and what's deliberately out of scope.
- Govern
The upload audit trail — who wrote what, and when
Every upload-link issuance and every claim lands in `upload_link` — a governed, forensic record of who touched the workspace. Read the trail from the dashboard, from `info`, and (for operators) directly from Postgres.
- Connect
Connect a dataset, analyze it, get results back
The full round-trip on connect0 today — connect a dataset into the core, have your agent run analyses via `sh`, retrieve the results, and where each step has friction in the current toolset.
- Connect
Connect a CSV to your agent
Connect a spreadsheet into the core — generate a pre-signed link, drop your file in a browser, and your agent reads it via `sh`.
- Run
The agent's simplest write — `sh "cat > file"` for one-liners
The simplest way for an agent running on the core to write a file — pipe text into it via the shell. When this beats the dedicated upload tools, and when to stop reaching for it.
- Run
Run an agent that scaffolds a new project
Let an agent running on your connect0 core write boilerplate into a fresh `/workspace/` with `upload.write`. A worked example of an agent as code generator on the core.
- Govern
Rotate or revoke R2 keys — controlled credentials, one place
Rotate the access key and every outstanding pre-signed URL dies at once. The clean, operator-controlled rotation procedure across apps/cf-sandbox, apps/mcp, apps/web.
- Govern
Path canonicalisation rules — the core keeps writes in bounds
What target_path you can pass to `upload.create_link` and `upload.write`. Why the rules are strict — no project can escape its own prefix — and how to work around them.
- Govern
Scoped access — who can upload in a multi-user project
Every member's write is scoped by role and recorded by name. Here's how the access model governs uploads, what `viewer` can't do, and conventions for keeping members from clobbering each other.
- Connect
Connect long context as a file, not a paste
Stop pasting 10,000-line logs into chat. Connect them into the core and have your agent grep, summarise, and ask follow-up questions against the file.
- Run
Run an agent that iterates on a config file
Hand a config to an agent running on your connect0 core; it edits in place via `sh` and verifies with `cat`. The subtle-but-powerful pattern that turns the sandbox into a live config editor.
- Run
Run an agent that pushes its results to GitHub
Let an agent running on your connect0 core push its code-shaped output straight to GitHub with `sh "git push"` — the cleanest way off the sandbox until `download.create_link` ships.
- Connect
Egress + uploads together
A project's `egress` flag controls outbound network from the sandbox — not inbound uploads. Here's the distinction and a few corner cases.
- Connect
Get binary and large artifacts out of the core
Pulling a big binary out of the core today — chunked base64 through `sh`. Token-expensive and fragile, but it works until `download.create_link` lands.
- Connect
Get results out of the core
Data out of the core is still Connect. What works today for pulling files back from `/workspace` — small text via `sh "cat"` — what doesn't, and where we're heading.
- Connect
When an upload silently fails
The upload completed, the dashboard says `pending` forever. Walk the queue path — Worker logs, HMAC drift, R2 event rule misconfig.
- Connect
Connect a file straight from the dashboard
Pure-browser upload path — no MCP, no terminal, no agent in the loop. For when a human is sitting at connect0.ai and just wants a file in the core the agents run on.
- Run
Run a code review in an isolated sandbox
Drop a branch onto your connect0 core and let an agent run your test suite via `sh` in an isolated sandbox, reporting failures back — connect0 as a private CI runner your agents drive.
- Connect
Connect CI build artifacts into the core automatically
Use a service token to connect build outputs into a connect0 project, so a teammate's agent can inspect them without a manual handoff.
- Connect
Connect big binaries over a slow network
Connect multi-MB payloads into the core, why we bind `content_length` into the URL, and how to read a "size mismatch" 403 from R2.
- Run
Run an agent that keeps a persistent notebook on the core
Let an agent running on your connect0 core keep `/workspace/notes/` as a persistent shared journal — reading, editing and appending across conversations.