HybridInference Cloud Agent
Getting started
Complete local stack
Run
Ports and parallel stacks
Sandbox networking
Building through a local proxy
What the smoke test covers
Trying interactions during a turn
Developer guide
Set up a checkout
Find the code that owns a change
Keep the dependency boundaries
Run the relevant checks
Run CI locally
Changing an API
Packaging and documentation
Code structure
Start with the deployment boundary
Follow a control-plane request
API schemas are organized by domain
Follow a host execution
Shared operation profiling
Follow a browser action
Add a feature without losing the structure
Contributing
The short version
Checks before review
Continuous integration
Contracts
Concepts
Native conversation recall
Context status
Native session identity at the shared boundary
Other native CLIs
Release scope and remaining findings
Verification before accepting a deployment
Current investigation evidence (2026-09-07)
Local verification update (2026-09-08)
Agent admission policy
Permissions and request checks
Failure behavior
Infrastructure credentials
Verify the Gateway contract
Rollout
Local verification (2026-09-10)
Minimal Agent identity
Tokens and sessions
Database identity boundary
Upgrade an existing deployment
Rollback and restore constraints
Local verification (2026-09-10)
The gateway contracts this service depends on
What these are, and what they are not
Source commits
What these do not cover
The one document here that is ours
Checking them
Security
Reporting a vulnerability
What is in scope
What a deployment must not assume
Operations
Cloud agent sandbox — operations
Admin Settings
Sandbox archive storage
Database browser
pgAdmin
What a job does
Temporary workspaces
Automatic task titles
Draft prompt rewriting
Conversation status and run history
Native agent questions
Who may run a job against which repository
Sandbox inventory, resource usage, and controls
The owner’s Usage page
Reading a task’s recorded events
MCP servers
Listeners and connections
Authorization and routing
End-to-end coverage
Connector configuration
Deployment and rollback
Runtime boundaries
What
--strict-mcp-config
is holding shut
Before a job can run for real
0. The sandbox network needs its host rules, a resolver and both relays
1. Only enrolled sandbox hosts run jobs
2. Credentials
Running self-hosted
Host configuration reference
Provisioning Kata on a runner host
Guest tracing and member isolation
Guest networking
Existing runc groups and activation checks
Scheduling and runtime attestation
How many runners
Member process cleanup
Fork compatibility and turn ordering
Execution slots
Removing a server
Sandbox settings
Sandbox archives
Restorable checkpoints
Restoring a removed host’s sandboxes
Environment installation snapshots
Launch failures and queue order
One sandbox-group inactivity clock (and separate safety watchdogs)
Lost attempt leases
Safety watchdogs
Resume, Fork, and publication
Complete local stack and retained database credentials
Rolling deployment order
Host and control-plane readiness
Rollback compatibility
Cold starts and failed deployments
Preserving an old-chain database
Rebuilding the agent database
Applying migrations that are not backwards-compatible
Retained Docker storage on a host
How full is the sandbox storage?
What the reading measures
Attesting the storage topology
Refreshing or disabling the metric
Measurement limits
Which machine runs the jobs
Running runners on another machine
Authorizing the tunnels on the far machines
The way back: the control plane reaching this host’s sandbox manager
Three things about this topology that look like details and are not
The sandbox network
What it allows and refuses
MCP prerequisite and accepted inference-grant risk
The host tables
Overlapping pools
Choosing the resolver
Protecting more addresses
When something is refused
One-time cleanup when upgrading to the one network
Runtime verification
Verified
Not verified
Known gateway findings
Model behaviour observed on the first real run
What changed when this moved
Historical statements that remain historical
SSH servers
Reusable cloud environments
Environment inventory
Settings and bootstrap configuration
Sandbox Manager naming compatibility
The one rule
Provisioning status
Local development tools
Control plane (
cloud_agent
)
Local and CI permission regression
Database
Automatic PR merge archiving
pgAdmin database administration
Gateway contracts
Own secrets
Sandbox deletion archives
Behaviour switches read by the control plane
Source control
MCP
Sandbox settings from the admin pages
Optional compute-resource management
Host agent (
cloud_agent_host
)
The stack’s own identity
Scheduling
Sandbox Manager, runtime and reporting
Physical servers and execution environments
Sandbox isolation (host agent reads, sandbox inherits)
Kata runtime qualification generation
Complete local stack database recovery
Claude inference retry policy
Agent CLI version pins (image build)
Web (
apps/frontend/
)
Build-time: the image variant
Runtime: the deployment’s identity
Set on the HybridInference side — not here
Infrastructure (not environment variables)
Adding a variable
Repository environments
Compute resources and the global sandbox location
What must remain on stable infrastructure
Supported initial deployment
Preferred CloudLab node types
Sandbox storage path
Prepare a trusted deployment profile
Automatic setup
Manual and file-backed setup
Three tunnels and the sandbox manager route
CloudLab nodes that register their own host keys
Enable legacy file-backed profiles
Day-to-day workflow
Recovery and release boundaries
Automatic CloudLab node replacement
Acceptance before enabling production traffic
Releases
What the generator checks, and what it deliberately does not
Producing one
Starting, not just building
Control-plane integration acceptance
Registry layout is not part of this contract
Where this differs from the design document
Deploying a recipe
Deploying the two in the order the design specifies
What a downstream deployment still owns
Deployment failure checks and queue monitoring
Drain through both activations
Before stopping a serving runner
Host runtime qualification
Network verification and startup work
Empty-queue waits and CI evidence
Old process, candidate schema
Detection after deployment
Recovery boundaries
Snapshot publication failures
Backup and recovery
Initial operating policy
What belongs in a recovery set
Capture a coordinated set
Restore and verify before reopening
Recover a previous artifact release
Automatic session archiving after a PR merge
Components and integration points
Which sessions are archived
Archive actions
Configuration and rollout
Failure handling and recovery
Timing and acceptance
Host runtime settings
Host execution limits
Runner lease failures
Lease timing and retries
Diagnose from positive evidence
Reporting and acknowledgement failures
When a retained conversation can continue
The safe release case: a child never accepted its turn
Staging end-to-end smoke
What a passing run proves
0. Before you start
1. Configure
2. Start the control plane
3. Sign in — the identity flow end to end
4. Enrol the host
5. One job, all the way
6. The parts that only fail later
7. Tear down
Log
Partial run, 2026-08-04
The identity contract, both halves real (same day)
The lookup contract, against real responses (same day)
HybridInference Cloud Agent
Index
Index