Cloudpack and Cloud Agents
An operating system for agent work — how we keep cloud agents useful without making them reckless.
Most of the value of an AI agent isn’t the model — it’s the operating system around it. This is the explainer we built internally for how our cloud agents run: what modes they operate in, how they stay safe, and what proof they have to come back with. The deck is embedded below as an interactive slideshow — click the arrows or dots, or use your keyboard. Hit View all slides to read it as one long page.
Make cloud agents useful without making them reckless.
Cloudpack gives agents a shared way to investigate, plan, change, operate, verify, and hand work back. Cloud agents execute inside that system.
PACK
Cloudpack turns “AI helped” into “the work is trustworthy.”
It puts a repeatable shape around agent work so speed does not come from skipping context, approvals, or proof.
Less stall
Agents know which mode they are in and what to do next, so they do not stop for questions that evidence can answer.
Less rework
The loop forces the agent to inspect dependencies and define proof before it edits the system.
More trust
Every meaningful result comes with a concrete handoff: what changed, what proves it, and what remains.
value = autonomy × evidence × repeatability
Different people get a different kind of relief.
It reads the repo rules, follows the delivery path, tests the right thing, and brings back a reviewable result.
The handoff explains the causal path and names the test, sandbox, screenshot, or query behind the claim.
One work loop replaces a collection of personal habits and one-off prompt rituals.
Production stays protected. Development and integration environments have distinct jobs and explicit checks.
The difference is not a smarter prompt. It is a better operating path.
Context lives in the chat. The agent may miss local rules, test the wrong surface, or stop at a plausible patch.
The agent follows a known route and returns evidence that another person can inspect.
Cloudpack does not promise perfect agents. It makes their behavior legible, bounded, and easier to correct.
One loop. Four modes. No persona sprawl.
The work changes shape by mode and risk, not by inventing a new agent identity for every request.
same loop / different proof bar
The agent starts by making the work explicit.
This internal contract keeps the agent from treating every task as “edit files until it looks right.”
Classify
Mode, scope, side effects, deliverable, verification.
Investigate
Read the system and gather evidence before choosing.
Choose
Pick the smallest approach and define the proof.
Execute
Work in controlled increments and reassess.
Verify
Use the strongest practical evidence, then hand off.
The loop is intentionally boring. Boring is what makes it repeatable.
Safety comes from boundaries and proof, not from asking permission for everything.
Evidence before preference
If code, data, or a safe test can answer the question, the agent probes before it asks.
Hard stops win
Access controls, protected environments, and missing business decisions override a numeric complexity score.
Strongest practical proof
Tests are not the only proof. Use integration checks, UI evidence, queries, and rollback readiness when they fit.
Lessons become structure
When a pitfall repeats, encode it in a learning, script, or runbook instead of relying on memory.
autonomy is earned by verifiable work
A cloud agent is a worker with a clean environment and a delivery contract.
Cloudpack defines how the worker thinks and reports. The repository pack defines where it may work and what counts as done.
Iterate
Targeted deploys and narrow tests in an isolated development org.
Prove
Full affected suite, coverage, integration behavior, and UI evidence.
Deliver
Conflict preflight, reviewable handoff, and promotion-aware evidence.
Production is read-only for the agent path. Delivery is a separate, visible step.
Suppose the ticket is fuzzy: “fix the Closed Won launch-date issue.”
The pack turns a vague request into a sequence that can expose the real dependency chain before code changes land.
It does not assume the symptom is the whole system. It inspects the trigger, flow, validation rule, and related records.
The opportunity, products, and assets each have their own state and documentation requirements.
It changes the minimum slice, runs representative tests, and proves the behavior in the integration sandbox.
What failed, why it failed, what changed, what remains unchanged, and which evidence supports the result.
Use cloudpack when you want agents to do more than generate a first draft.
It gives the team a common operating model for agent work: investigate with evidence, change in controlled slices, verify the real outcome, and hand back something another person can trust.
Cloudpack is the system. Cloud agents are the workers. The value is trustworthy progress.