DigitalOcean Cuttlefish & Managed Agents: The Complete Guide for Agentic AI Architects (2026)

An AI agent runs a recursive delete against a production directory at 2:37 AM. The engineer who launched it is asleep. The sandbox catches the call, flags it as high-risk, and the session stalls — waiting for a human who isn’t at a screen.

This is the scenario that killed multi-hour agent runs before DigitalOcean shipped Cuttlefish: a native iOS app that lets you approve, deny, steer, and stop AI agent sessions from your phone. Combined with Managed Agents — DigitalOcean’s full-stack infrastructure for running agentic workloads in hardware-isolated Firecracker microVMs — it solves a problem that every production agent team hits: agents need human oversight, but humans aren’t always at their desks.

This guide breaks down both products for architects evaluating agent infrastructure in 2026. We’ll cover the architecture, the supervision model, the tool ecosystem, the Box partnership, pricing, and where it fits against alternatives like Fly.io Sprites, E2B, Modal, and Daytona.

Table of Contents

• Why This Matters Now
• Managed Agents Architecture: The Full Stack
• Harness Runtime: Firecracker MicroVMs for Agents
• Action Gateway: 16,000+ Governed Tools via MCP
• Cuttlefish: Human-in-the-Loop from Your Pocket
• Box Mount: Enterprise File Sync for Agent Workspaces
• Supported Harnesses and Frameworks
• Observability and Signals
• Pricing: Per-Second Active CPU Billing
• Competitive Landscape: How It Stacks Up
• Getting Started: From Zero to Running Agent
• Production Considerations for Architects
• What This Means for RPA Teams
• FAQs
• Key Takeaways
• References

Why This Matters Now

The AI agent infrastructure market is moving fast. According to recent industry analysis, the AI workflow automation market is projected to reach $97.9 billion, and a growing share of that spend is shifting from hosted model APIs to the layer underneath: execution, tooling, and governance infrastructure for autonomous agents.

The problem is a classic infrastructure gap. You can build an agent with LangGraph, CrewAI, or Claude Code in an afternoon. But running it in production — with isolated sandboxes, governed tool access, pause/resume for long-running tasks, human approval for sensitive operations, and observability across the full execution chain — requires infrastructure that most teams either build from scratch or bolt together from three or four services.

DigitalOcean’s pitch with Managed Agents is to collapse that stack into one platform. And with Cuttlefish, they’ve added the one piece that no cloud provider had shipped as a first-party product: mobile supervision.

That matters because agentic workloads are fundamentally different from traditional cloud compute. Agents make decisions. They call external APIs. They write and execute code. They sometimes do things you didn’t expect. The approval loop — the moment where a human reviews what an agent wants to do before it does it — is the single most important safety primitive in production agent systems. And until Cuttlefish, that loop was chained to a laptop screen.

Managed Agents Architecture: The Full Stack

Managed Agents, currently in public preview following a private preview period, is built on two core services that work together but can also be used independently:

More Read

AWS Dogwood & AgentCore Temporal Policies: The Agentic AI Architect’s Guide (2026)

Building with Google Agent Studio: The Complete Guide to Gemini Enterprise Agent Platform

DigitalOcean Managed Agents: How Firecracker MicroVMs and 16,000+ MCP Tools Are Reshaping Agent Infrastructure (2026)

On top of these sits Cuttlefish — the mobile supervision layer — and integrations with DigitalOcean’s existing inference engine, GPU Droplets, and observability stack.

The platform is designed to run any agent framework, not just DigitalOcean’s own. It supports Claude Code, Codex CLI, OpenCode, Hermes, LangGraph agents, and any custom agent packaged as an OCI container image. This “bring your own harness” approach is a deliberate architectural choice — DigitalOcean provides the execution and governance infrastructure; you bring the agent logic.

For the background on how the Katanemo Labs acquisition in April 2026 shaped this platform, see DigitalOcean’s acquisition announcement. Katanemo’s team brought expertise in model inference optimization and agentic infrastructure that now underpins both the Inference Engine and Managed Agents.

Harness Runtime: Firecracker MicroVMs for Agents

Harness Runtime is the compute and session management layer. Each agent session runs in a dedicated Firecracker microVM — the same virtualization technology that powers AWS Lambda and Fargate — with its own compute allocation, filesystem, and network stack. This is hardware-level isolation, not container-level: one session cannot see another’s memory, processes, or files.

Session Lifecycle

The session lifecycle is where Harness Runtime differentiates itself from simpler sandbox providers:

These benchmarks are from DigitalOcean’s internal testing (September 2026) using Codex CLI with the gpt-5.5 model, running in DigitalOcean’s RIC1 region. The comparison target was Fly.io Sprites with matching parameters, though Sprites provisioned a larger guest (8 vCPU/16 GB vs. the requested 2 vCPU/4 GB), so direct comparison requires caveating.

The pause/resume capability has major cost implications. When an agent is waiting for a human approval, waiting for an external API callback, or simply idle between tasks, you can pause the session — CPU and memory billing stop, only retained storage remains billable. For long-running agentic workflows that involve intermittent human review, this can cut compute costs significantly. For a deeper look at managing the cost side of agent infrastructure, see our guide on AI Agent FinOps and token economics.

Built-in Tooling

Every Harness Runtime microVM ships with:

• Chromium — for browser-based agent actions (web scraping, UI testing, form filling)
• Coding sandbox — full development environment with dependency installation
• Exec API — run commands, tests, and environment inspection programmatically
• Port forwarding — security-hardened preview of apps and services running inside the session, without public exposure

Custom agents can be packaged as standard OCI container images and turned into reusable environment templates, allowing teams to standardize their agent configurations across projects and teammates.

Action Gateway: 16,000+ Governed Tools via MCP

Action Gateway is a managed MCP (Model Context Protocol) endpoint that gives agents access to over 16,000 tools across more than 500 providers through a single integration point. Rather than each agent session managing its own API keys, OAuth flows, and rate limits, Action Gateway centralizes all of this.

How Tool Governance Works

The governance model follows a layered permission architecture:

1. Team-level tool policies — define which tools and actions each agent or team can access
2. Environment-level permissions — set defaults (allow, deny, or ask) for categories of actions
3. Runtime approval — sensitive operations trigger a human approval request via Cuttlefish or the web console

Credentials are brokered at execution time by Action Gateway and never reach the model or the sandbox. This addresses one of the most dangerous patterns in agent deployments: agents with direct access to production API keys. With Action Gateway, the agent never sees the credential — it requests a tool action, the gateway authenticates on its behalf, and the result comes back.

Authentication options include API keys, shared OAuth applications, and per-user OAuth. When an agent needs authorization that hasn’t been granted yet, the gateway provides a sign-in link and suspends the tool call until authorization completes — then resumes the call automatically.

Key Connectors

Named first-party connectors include:

Teams can add their own MCP servers and internal tools. The gateway also works independently of Harness Runtime, so it can serve as the tool layer for agents running on other infrastructure. This is a notable architectural decision — it means you could use DigitalOcean’s Action Gateway with agents running on your own VMs, in another cloud, or on-premises.

Tool Discovery

With 16,000+ tools available, context window pollution is a real concern. Action Gateway includes an intent-based tool discovery system that surfaces relevant, approved tools based on the agent’s current task without loading the entire catalog into context. DigitalOcean’s internal testing reported 99.3% intent-to-tool matching accuracy, though the testing methodology has not been published.

For a broader perspective on how the control planes for AI agent traffic are evolving across the industry, see our coverage of Cloudflare’s AI Agent Management — a complementary approach focused on the network layer rather than the execution layer.

Cuttlefish: Human-in-the-Loop from Your Pocket

Cuttlefish is the product that turns Managed Agents from a backend infrastructure play into a complete supervision platform. It launched November 5, 2026 as a native iOS app (no Android or web client yet), and it solves the problem we opened with: agents need human oversight, but the human isn’t always at a desk.

Core Capabilities

Live session monitoring — Replies, reasoning traces, and tool calls stream in real time. You see what the agent is thinking, not just what it outputs. Transcripts are cached locally so reopening a session resumes where you left off rather than replaying the full history.

Approve or deny tool calls — When an environment’s permission policy is set to “ask” for a given action, the agent waits for a human decision. Cuttlefish shows the full command, file path, or diff — not a summary — so you can make an informed decision. You can deny with a reason, which is stored with the decision for auditability.

High-risk request handling — Requests flagged as risky — recursive deletes, force-pushes, sudo commands, piped internet-to-shell scripts — require Face ID or device passcode before approval. This is a material security feature: even if someone gains access to your unlocked phone, they can’t approve a destructive agent action without biometric verification.

Mid-run steering — Send corrections, additional context, or new instructions while the agent is working. Messages sent during active execution are queued for the agent’s next task boundary. You can also pause, resume, or stop sessions entirely.

File and artifact management — Browse workspace files, upload files and photos, share files the agent produced. For web-based outputs, Cuttlefish scans the sandbox for open ports (e.g., Next.js or Python dev servers) and renders them inline.

Checkpointing and forking — Create restore points, fork sessions into independent branches, or roll back to a previous checkpoint — all from the phone.

Team collaboration — Multiple teammates can join or take over a session. The app shows who is currently in a session, enabling handoffs between team members across time zones.

What Cuttlefish Cannot Do (Yet)

There are limitations. You cannot create or edit Toolbelts, modify environment tools, connect provider accounts for Action Gateway, answer questions the agent asks (as opposed to tool-call approvals), or do in-depth code review. These all require the web console, doctl CLI, or API. The agent-question limitation is particularly notable: if an agent asks a clarifying question rather than requesting a tool call, you currently can’t answer it from the app.

The Supervision Model This Enables

Cuttlefish makes a specific operational pattern viable: launch long-running agent sessions, walk away, and handle approvals asynchronously from wherever you are. This is fundamentally different from the current norm of babysitting an agent in a terminal window.

Consider a realistic workflow: An agentic coding assistant is migrating a codebase from one framework to another. The job takes hours. Without mobile supervision, you either leave the agent fully autonomous (risky for production-adjacent work) or stay at your desk watching a terminal. With Cuttlefish, you launch the session, go about your day, and your phone buzzes when the agent wants to write to a protected file, push to a branch, or run a potentially destructive command. You review the diff, tap approve (with Face ID for the dangerous ones), and the agent continues.

This pattern of asynchronous human oversight is central to the AgenticOps discipline emerging across the industry. For a deep dive into production monitoring patterns, see our guide to AI Agent Observability in Production.

Box Mount: Enterprise File Sync for Agent Workspaces

Box Mount, launching in private preview alongside Cuttlefish, bridges the gap between enterprise content management and agent workspaces. It syncs a Box folder into a Managed Agents environment so agents work on the same files under Box’s permissions, version history, and audit trail.

How It Works

1. In Cuttlefish: navigate to Customize → Tools → Box
2. Sign in with your Box account
3. Select which Box folder to mount
4. The selected folder appears as plain files in the agent’s workspace

Edits the agent makes upload to Box. Changes made in Box appear in the workspace. Deletions sync bidirectionally. Each user syncs with their own Box account, so access is scoped to what that user can see in Box.

Why This Matters for Enterprise Adoption

Enterprise teams have a recurring blocker with agent tooling: corporate files live in systems with access controls, version histories, and compliance audit trails. Giving an agent raw access to those files outside the content management system breaks the governance chain. Box Mount keeps the governance chain intact — the agent works on files, but Box still controls who can access them, tracks every version, and maintains the audit log.

The legal team scenario DigitalOcean describes — an agent summarizing contract documents, pausing for lawyer approval before writing the summary, with the output landing in a Box folder under full audit trail — is exactly the kind of workflow that compliance-sensitive organizations need before they’ll deploy agents against real corporate data. For more on the governance frameworks emerging for these workflows, see our coverage of EU AI Act compliance for AI agents.

Supported Harnesses and Frameworks

Managed Agents explicitly supports the following agent harnesses and frameworks:

The OCI container option is key for production teams. If you’ve built a custom agent using AutoGen, MetaGPT, smolagents, or any other framework, you can package it as a container image and deploy it on Managed Agents without waiting for first-party support. The platform provides the execution sandbox, tool access, and supervision layer; your container provides the agent logic.

DigitalOcean also supports subagent and parallel session patterns — one session can spawn additional sessions across different repositories or tasks, enabling divide-and-conquer, collaboration, and map/reduce workflows. The APIs for these are packaged as “skills” for each supported harness.

Observability and Signals

Production agent systems need observability that goes beyond traditional application monitoring. An agent session generates a fundamentally different telemetry shape: tool calls, model requests, file operations, approval decisions, and token consumption all need to be tracked and correlated.

Managed Agents provides structured events for:

• Tool calls (what was called, arguments, response, duration)
• Model requests (prompt, response, token counts, latency)
• File operations (reads, writes, deletes)
• Approval activity (request, decision, latency, reason for denial)
• Session logs and metrics

Two additional observability products are in development:

Insights (Private Preview) — Follows a run across Harness Runtime, Action Gateway, and built-in tools, providing an end-to-end view of what an agent did and why.

Signals (coming soon) — Turns agent runs into structured feedback for evaluation and reinforcement learning. This is a particularly interesting direction: using production agent behavior to automatically improve agent performance over time, rather than relying solely on manual prompt engineering.

Pricing: Per-Second Active CPU Billing

Managed Agents uses per-second active CPU billing — you pay for the CPU your agents actually consume, not for allocated capacity sitting idle.

DigitalOcean published a worked example: a session with 2 vCPUs at 25% average utilization and a 4 GB memory peak running for one hour costs approximately $0.060 in actual CPU and memory usage, compared to $0.126 for the fully allocated capacity. That’s a 52% saving from usage-based billing alone — before accounting for pause/resume, which can reduce the billable window further.

The Cuttlefish iOS app itself is free. Pricing for Box Mount has not been announced.

For per-unit rates, refer to DigitalOcean’s Harness Runtime pricing page.

Competitive Landscape: How It Stacks Up

The agent infrastructure market has gotten crowded in 2026. Here’s how Managed Agents compares to the leading alternatives:

Where DigitalOcean Wins

Breadth of the integrated stack. No other provider combines sandbox execution, a managed tool gateway with 16,000+ tools, mobile supervision, and enterprise file sync in one platform. Competitors typically cover one or two of these; the rest is left for the customer to build or integrate.

Mobile-first supervision. Cuttlefish is unique. No competitor has a native mobile app for agent oversight with biometric-gated approval flows.

Enterprise-readiness signals. Box Mount, credential brokering (secrets never reaching the sandbox), and structured audit events speak directly to the compliance concerns that block enterprise agent adoption.

Where Competitors Win

Exec latency. Fly.io Sprites benchmarked at 79 ms for command round trips vs. Managed Agents’ 189 ms. DigitalOcean acknowledges this gap — the overhead comes from routing through their edge and control plane for auth and audit. For latency-sensitive agentic workloads, this matters.

Ecosystem maturity. E2B and Modal have been in the sandboxed code execution space longer and have deeper integrations with specific agent frameworks. Modal’s GPU support is more mature for inference-heavy workloads.

Open-source ethos. Daytona’s open-source approach gives teams full control over the agent execution layer, which some organizations prefer for on-premises deployments where cloud-hosted agents aren’t an option.

Getting Started: From Zero to Running Agent

CLI Quick Start

# Install and authenticate doctl
doctl auth init

# Launch a Claude Code agent session
doctl harness-runtime launch --harness claude-code --name my-first-agent

# Reattach to the session later
doctl harness-runtime launch my-first-agent

# Detach without stopping: Ctrl-D

Environment Spec (YAML)

agent: opencode
tools:
  - do.actions
permissions:
  default: ask

Note: the spec doesn’t require a model key — Managed Agents uses DigitalOcean’s native inference integration.

Cuttlefish Setup

1. Download Cuttlefish from the App Store (requires iOS 26.5+)
2. Sign in with your DigitalOcean account — all six OAuth scopes must be allowed
3. Select your team (the team must have Managed Agents access)
4. Choose your harness (Claude Code, Codex CLI, OpenCode, etc.)
5. Launch a session and start working

The app requires these OAuth scopes: agent_harness_session:read, agent_harness_session:create, agent_harness_session:operate, agent_harness_session:manage, action_gateway:read, genai:read. Clearing any scope during sign-in will cause authentication to fail.

Production Considerations for Architects

Security Architecture

The security model is defense-in-depth:

• Hardware isolation — Firecracker microVMs with separate memory and process spaces per session
• Credential separation — Action Gateway brokers credentials at execution time; they never enter the sandbox or model context
• Tiered permissions — Team → Environment → Runtime approval chain
• Biometric gating — Face ID / passcode required for high-risk approvals on mobile
• Audit trail — Structured events for every tool call, approval decision, and file operation

Cuttlefish-specific: sign-in tokens are stored in the iPhone Keychain only, not synced to other devices. Cached transcripts and session lists are excluded from device backups and deleted on sign-out. DigitalOcean states that no analytics, advertising, or crash-reporting SDKs are included in the app.

Cost Optimization Patterns

Several architectural patterns can reduce costs significantly:

• Aggressive auto-pause — Configure tight idle thresholds so sessions that are waiting for external events automatically pause and stop incurring compute charges
• Checkpoint before exploration — Create a checkpoint before an agent enters an exploratory phase, so you can roll back without paying for wasted work
• Shared environments with per-user auth — Use per-user OAuth through Action Gateway so multiple team members share one environment configuration while maintaining individual credential scoping
• Tool discovery over full catalog loading — Leverage Action Gateway’s intent-based discovery rather than loading all 16,000+ tools into context, which saves both token costs and inference latency

Limitations to Plan Around

• iOS only — No Android app, no mobile web interface. Android users and teams standardized on Android devices need the web console or CLI for now.
• Agent questions vs. tool calls — Cuttlefish can approve tool calls but cannot answer clarifying questions from agents. If your agent asks “which branch should I deploy to?” rather than making a tool call, you’ll need to answer via doctl or the web console.
• Exec latency — 189 ms per command round trip (vs. 79 ms for Sprites). For agents that make thousands of small shell commands, this overhead compounds.
• Public preview status — No published SLA, and features may change. Not recommended as the sole path for production workloads that require contractual uptime guarantees — yet.
• Region availability — Specific regions supporting Managed Agents have not been published in the sources reviewed.

What This Means for RPA Teams

If you’re coming from the RPA world — UiPath, Automation Anywhere, Blue Prism — you’ll recognize the problem Cuttlefish solves. Traditional RPA platforms have had attended automation and human-in-the-loop approval workflows for years. Attended bots pause, show a screen to an operator, wait for a decision, and continue. The concept isn’t new.

What’s new is applying it to AI agents that write and execute code. An RPA bot follows a deterministic flowchart — the approval points are predefined. An AI agent is non-deterministic — it decides what to do at runtime, which means the approval points are also runtime decisions. That’s a fundamentally harder supervision problem, and it’s what makes the combination of permission policies (predefined) with runtime approval (dynamic) in Managed Agents architecturally interesting.

For RPA teams evaluating agentic AI adoption, Managed Agents offers a migration path: you can run existing agent frameworks (LangGraph, CrewAI) in governed sandboxes with human oversight patterns that map to concepts you already understand from attended automation. The tool governance in Action Gateway maps to the concept of credential management in Orchestrator. The audit trail maps to production logging. The mobile supervision maps to attended-bot interaction.

The gap is that DigitalOcean’s platform doesn’t integrate natively with RPA orchestrators (UiPath Orchestrator, Automation Anywhere Control Room, etc.) — yet. As the $97.9 billion AI workflow automation market continues to converge, expect these integration points to emerge.

Frequently Asked Questions

Does Cuttlefish work on Android?

No. As of November 2026, Cuttlefish is iOS only (requires iOS 26.5+). There is no Android app, web app, or mobile web interface. Android users must use the DigitalOcean web console or the doctl CLI for agent supervision.

Can I use Managed Agents with my own LLM models?

Yes. While Managed Agents integrates natively with DigitalOcean’s Inference Engine, the agent harnesses themselves can be configured to use any model provider. Since you can bring custom OCI container images as harnesses, you control which models your agent calls.

How does DigitalOcean handle secrets in agent sandboxes?

Secrets entered during environment setup go to DigitalOcean’s secret store and are removed from the environment spec. They’re never shown again and never enter the sandbox or model context. Action Gateway brokers credentials at execution time — the agent requests a tool action, the gateway authenticates on its behalf, and the result returns. Secrets for Action Gateway tools are rotated and scoped per-session.

What happens if I lose phone connectivity while an agent is waiting for approval?

The agent session runs on DigitalOcean infrastructure, not on your phone. It will wait for the approval indefinitely (or until a session timeout, if configured). Once you regain connectivity, the pending approval will appear in Cuttlefish. You can also approve via the web console or doctl in the meantime.

Is Managed Agents ready for production workloads?

Managed Agents is in public preview. DigitalOcean has named production customers (OpenHands, Qencode, Amplitude), but there is no published SLA. For mission-critical workloads requiring contractual uptime guarantees, evaluate the preview terms carefully and plan for fallback paths.

Key Takeaways

• Cuttlefish is the first native mobile app for AI agent supervision — approve tool calls, steer runs, and manage sessions from your iPhone with biometric gating for high-risk actions.
• Managed Agents combines execution + tool governance + supervision in one stack — Harness Runtime for Firecracker microVM sandboxes, Action Gateway for 16,000+ governed tools via MCP, and Cuttlefish for mobile oversight.
• Per-second active CPU billing with pause/resume means you only pay for compute your agents actually use — paused sessions incur only storage costs.
• Box Mount brings enterprise file governance to agent workspaces — agents edit files under Box’s permissions, version history, and audit trail.
• Multi-harness support (Claude Code, Codex CLI, OpenCode, Hermes, LangGraph, custom OCI) means you’re not locked into one agent framework.
• The 189 ms exec latency is the main competitive gap against Fly.io Sprites (79 ms) — DigitalOcean acknowledges this and attributes it to auth/audit overhead in the control plane.
• For RPA teams, the permission policies + runtime approval pattern maps directly to attended automation and human-in-the-loop concepts from traditional RPA orchestration.

References

1. DigitalOcean. “Introducing Cuttlefish.” November 5, 2026. https://digitalocean.com/blog/introducing-cuttlefish
2. DigitalOcean. “Managed Agents Public Preview.” September 22, 2026. https://digitalocean.com/blog/managed-agents-public-preview
3. DigitalOcean Docs. “How to Steer and Approve Harness Runtime Sessions from the Cuttlefish iOS App.” November 5, 2026. https://docs.digitalocean.com/products/managed-agents/agent-harness-runtime/how-to/use-cuttlefish-ios-app/
4. DigitalOcean. “DigitalOcean Acquires Katanemo Labs to Accelerate the Inference Cloud for the Agentic Era.” April 2, 2026. https://www.businesswire.com/news/home/20260402272982/en/
5. DigitalOcean. “MicroVMs for Agents.” 2026. https://digitalocean.com/blog/microvms-for-agents
6. DigitalOcean. “DigitalOcean Signals: Observability for AI Agents and Inference.” October 28, 2026. Referenced via product page
7. Fly.io. “Sprites vs E2B vs Modal vs Daytona: Agent Sandboxes Compared.” 2026. https://fly.io/learn/sprites-vs-e2b-vs-modal-vs-daytona/
8. DigitalOcean Docs. “Managed Agents.” https://docs.digitalocean.com/products/managed-agents/
9. DigitalOcean. “Harness Runtime Pricing.” https://www.digitalocean.com/pricing/harness-runtime

Social Media Post (X/Twitter)

DigitalOcean just shipped Cuttlefish — approve AI agent tool calls from your iPhone with Face ID. Built on Managed Agents: Firecracker microVMs, 16K+ tools via MCP, Box Mount for enterprise files. First mobile-native agent supervision app. Full guide 👇

LinkedIn Post

The biggest blocker in production AI agent deployments isn’t the model — it’s the approval loop.

An agent stalls at 2 AM asking permission to write to a protected file. The engineer who launched it is asleep. The session dies.

DigitalOcean just launched Cuttlefish — a native iOS app that lets you supervise AI agents from your pocket:

• Approve/deny tool calls with the full diff visible
• Face ID for high-risk actions (recursive deletes, force-pushes)
• Steer, pause, resume, or stop sessions mid-run
• Browse workspace files and artifacts

It runs on top of Managed Agents — DigitalOcean’s full-stack agent infrastructure: Firecracker microVM sandboxes, 16,000+ governed tools via a managed MCP gateway, Box Mount for enterprise file sync, and per-second active CPU billing.

Wrote a full architecture guide covering the platform, competitive landscape (vs. Fly.io Sprites, E2B, Modal, Daytona), pricing, and what it means for RPA teams moving into agentic AI.

#AgenticAI #AIAgents #DevOps #RPA #DigitalOcean #Cuttlefish #AIInfrastructure

Image Suggestions

1. Architecture diagram — Layered architecture showing Harness Runtime (Firecracker microVMs), Action Gateway (MCP tools), Cuttlefish (mobile supervision), and Box Mount converging into the Managed Agents platform
2. Competitive comparison table visual — Visual summary of the platform comparison table (DigitalOcean vs. Sprites vs. E2B vs. Modal vs. Daytona)
3. Supervision flow diagram — Showing the lifecycle: Agent requests tool call → Risk classification → Cuttlefish notification → Face ID gate → Approve/Deny → Agent continues