Message your agent from any surface
0:00 / 0:00
Governed Runtime for AI Agents
The runtime that lets AI agents do real work
Cuttlefish operates your real browser, runs on your actual computer, builds fully interactive applications, remembers everything that matters, and carries work forward across days and weeks, all under policy enforcement and cryptographic audit from the first action to the last receipt. Switch between your AI models mid chat with no context loss. You bring the intelligence. We bring the infrastructure.
0:00 / 0:00
One System, Every Way In
One system, different ways to work.
Start in chat, drop in with the quick input bar when you need speed, voice when your hands are busy. Floating approvals when the main window is hidden. Mobile when you're away from the desk. Cuttlefish keeps the same context, memory, and task state across every mode — nothing resets when you change surfaces so work moves forward instead of restarting every time the surface changes.
Floating Approvals
High-risk actions surface desktop notifications and approval prompts while the main window stays out of your way.
Mobile Remote
Check progress, approve actions, redirect work from your phone over an HMAC-signed relay. Commands execute on your machine, not a server.
Inline Results
Generated applications, data visualizations, research briefs, and structured deliverables appear directly inside the conversation as live, interactive surfaces — not links to another product.
One continuous system. Six ways to reach it. Zero context lost between them.
Bring Your Own Intelligence
Model Agnostic.
Switch without losing the thread.
Connect the providers you already use & pay for — OpenAI, Anthropic, Google, Azure OpenAI, xAI, DeepSeek, Mistral, Groq, Ollama running locally, or any OpenAI-compatible endpoint. Ten providers, zero vendor lock-in. Switch models between messages or mid-task without resetting memory, context, or progress.
From local Ollama to frontier models, all first-class.
GPT-5, Claude Opus 4.6, Gemini 3 Pro, Grok 4, and more. Every provider is a first-class citizen — not a fallback option.
Change models between turns. Nothing is lost.
Switch models between turns or between phases of the same job. Memory, context, and progress stay intact across every change.
One model for reasoning. Another for speed. Another for code.
Use the best model for each part of the work. Cuttlefish keeps everything aligned while you route by capability.
Your keys, your keychain.
API keys stored in your OS credential manager — macOS Keychain, Windows Credential Manager, Linux Secret Service. Never in flat files. Never on our servers.
No tenant model required.
We give you the enterprise Azure backend so you can just bring your own keys and run. No forced multi-tenancy. No shared credential pools.
Your intelligence. Your choice. We handle everything else.
Built in Real Browser, Three Collaboration Modes
Your real browser. Shared with your agent.
This is not a screenshot scraper. Cuttlefish joins the live browser on your machine — your tabs, your sessions, your logged-in accounts, your cookies. It reads the actual DOM, understands page structure before it acts, and lets you shift between three distinct collaboration modes without breaking the session and always under governance.
0:00 / 0:00
Stay signed in and pick up where you left off
Keep your tabs, logins, and browser context instead of restarting from a fresh automation session every time.
Understands the page before it acts
Works from the live structure of the page whenever possible, so actions are more reliable than screenshot-only automation.
Shared control instead of blind takeover
Browse normally, let the agent step in when needed, and take control back instantly without losing the session or the context.
Teach once, improve repeated work
Capture repeatable flows so Cuttlefish can follow better routes and get more reliable over time.
Websites, generated apps, localhost in one place
Open live sites, generated apps, local builds, and preview environments in the same browser surface.
Recovery when flows change
When a site shifts or a step fails, Cuttlefish can try alternate routes and verify the result before moving on.
Browse normally. Bring in the agent when it helps. Keep the session, the context, and the control.
Generative Canvas — Build Real Software, Ship It Live
Turn Ideas into deployable Interactive applications
The generative canvas builds real, fully interactive web applications, complete with working logic, state management, animations, and responsive layouts that your agent can deploy to any live hosted environment. You describe what you want. Cuttlefish generates it, renders it in a live governed iframe sandbox, and ships it. Iterate in place. Export as HTML, ZIP, or multi-file project. Or just share the live URL.
01
Describe
Tell your agent what to build. Plain language. No schemas, no boilerplate, no scaffold setup.
02
Generate
Cuttlefish builds a fully interactive application — real JavaScript, CSS, state, and data handling. Not a wireframe.
03
Preview live
The app renders instantly in a governed iframe sandbox. Results and data visualizations surface directly in the chat stream.
04
Iterate in place
Every refinement updates the existing output. No copy-paste, no restart. Multi-file workspaces with full tree, preview, and version history.
05
Export & deploy
Download as standalone HTML, ZIP, or multi-file project. Or deploy live and share a URL — straight from the conversation.
Works Across Your Computer, Not Just Inside a Chat Window
Files. Shell. Clipboard. Desktop apps. Its own interface.
Cuttlefish does not stop at the chat boundary. It can read and write files, run shell commands, manage your clipboard, interact with local applications, and navigate and mutate its own interface to open the right view, change a setting, or show you exactly where something happened — without waiting for you to click through menus.
Files
DIRECT FILE ACCESS
Read, write, organize, and update files where they already live on your machine.
Shell
SHELL EXECUTION
Run commands and scripts. Every invocation is policy-checked by Preflight before it executes.
Clipboard
CLIPBOARD INTEGRATION
Move content in and out of the system clipboard as part of any workflow.
Self-navigating
SELF-NAVIGATING INTERFACE
Cuttlefish opens its own tabs, navigates to settings, fills forms, and surfaces relevant views. It operates its own UI instead of telling you what to click.
Desktop
DESKTOP AUTOMATION
Interact with applications already running on your machine. Work across tools, not just inside one window.
Governed
POLICY BEFORE EVERY ACTION
Every capability is risk-classified. Preflight evaluates each action before it executes. Nothing slips through unexamined.
Persistent Memory That Compounds Over Time
It remembers. It connects. It gets sharper the more you use it.
Cuttlefish maintains a living world model — preferences, prior work, people, projects, decisions, and their relationships — that grows across every session. It does not just recall what you said last time or index from a RAG snippet. It understands how today's task connects to last week's decision, detects contradictions in your facts, consolidates overlapping knowledge, and brings the right context forward at the right moment.
Episodic memory
Past conversations, decisions, and outcomes remain accessible and useful, not buried in a transcript.
World model
People, projects, tools, commitments, and evidence stay linked in a structured, evolving understanding of your working world.
Contradiction detection
When new facts conflict with established knowledge, Cuttlefish surfaces the conflict instead of silently overwriting.
Memory consolidation
Repeated patterns and related facts are automatically compounded into stronger, more reliable knowledge.
Live context, not stale recall
Actions reflect the current state of the world, not only what was said three sessions ago.
Entity graph
Named entities — people, organizations, tools, projects — are recognized, linked, and kept up to date as your work evolves.
Memory architecture
Most AI tools reset at the session boundary. Cuttlefish does not. Memory here is structural — entities, relationships, decisions, contradictions, and open threads maintained as a living model of your working world.
Across days and weeks
Long-running context does not degrade across sessions. Work you started last week is still understood today.
Connected, not isolated
Cuttlefish understands how information relates — not just what it is in isolation.
Long-Horizon Missions — Work That Outlasts the Conversation
Active responsibilities across days, weeks, and months.
Some work should not end when the chat window closes. Cuttlefish runs long-horizon missions — persistent responsibilities that wake on schedule, respond to events, maintain their own progress, and escalate to you only when a real decision is needed. Monitoring. Recurring research. Follow-up sequences. Ongoing compliance checks. The mission stays alive. You stay in control.
Missions activate on schedule or on defined signals.
Cron schedules or reactive triggers — not just when you remember to ask. The mission wakes when it should, not when you prompt it to.
Objectives, context, and checkpoints carry forward.
Across every wake cycle, partial results and mission state persist without restarting from zero.
Cuttlefish brings you in for real decisions only.
Approvals, exceptions, and judgment calls surface to you. Everything else keeps moving.
Cuttlefish is useful in the moment and dependable across months.
Multi-Agent Execution — Delegate, Supervise, Verify
Spawn specialists. Supervise their work. Verify their results.
When a task is too complex or too broad for a single pass, Cuttlefish spawns child agents — each with a scoped mandate, its own context, and a model routed by strength. A code generation specialist handles the build. A security adversary attacks the output. A governance judge reviews the findings. You see every step, every delegation, and every result. Nothing happens in a black box.
Orchestrator
Cuttlefish determines when to spawn and what to delegate.
Automatic delegation decisions based on task complexity and scope. Results route back to the parent conversation when the work is done.
Specialist
Spawned specialists
Child agents handle scoped subtasks with their own context windows, execution state, and model routing. Each is purpose-built for its slice of the work.
Adversary
Security adversary pipeline
Generated UI and code is red-teamed by a dedicated adversary agent that tries to find vulnerabilities and policy violations before shipment.
Judge
Governance judge
The adversary’s findings go to a governance judge that makes the final determination. Results pass, get flagged, or get blocked. No self-certification.
Supervision runtime
Status, progress, delegated scope, and verification results — all visible as the work runs.
You give the instruction. Cuttlefish runs the team.
Governed by Design — Not by Guardrails
Policy before execution. Proof after. No exceptions.
Cuttlefish does not rely on a model promising to behave. Every action flows through a five-layer governance pipeline: OS-level isolation, Preflight policy evaluation, LiveGuard runtime monitoring, multi-agent security review, and Ed25519-signed cryptographic receipts stored in immutable WORM retention. What is allowed is defined in advance. What happened is provable afterward.
L1
Preflight
Every action — file access, shell command, API call, browser mutation — is evaluated against OPA/Rego policies and PACT DSL rules before it executes. Actions that fail Preflight never run.
L2
LiveGuard
Streaming output is monitored in real time. If content violates policy constraints mid-stream, the response is halted — not flagged after the fact.
L3
Cryptographic receipts
Every consequential action produces an Ed25519-signed receipt. Stored in append-only WORM logs. Cannot be modified. Cannot be deleted.
L4
Capability leasing
Capabilities are risk-classified, explicitly granted, and revocable. Unknown actions are denied by default.
L5
Consent and approval
High-risk actions pause for explicit user approval with full context. No progress is lost while waiting.
L6
Sub-100µs validation
Generated UI passes through a Rust-based validator in under 100 microseconds. Governance is real-time, not a bottleneck.
The result is not “trust us.” The result is visible control with cryptographic proof.
Policy before action
Important actions are evaluated before execution, not rationalized afterward.
Signed receipts
Ed25519-signed receipts and WORM retention keep consequential work auditable and tamper-proof.
Enterprise — Bring Your Own Intelligence, We've Got the Backend Covered
Same product. Organizational control. Azure-grade infrastructure.
Cuttlefish is not "personal edition plus an enterprise upsell." It is one product with two control postures. For organizations, the same desktop agent connects to a production-hardened backend running on Azure Kubernetes Service — 24+ Go microservices behind Istio service mesh, managed by ArgoCD, with Azure Front Door edge routing, Azure Key Vault secrets, PostgreSQL with PgBouncer, Redis caching, NATS JetStream real-time messaging, Event Grid integration, OpenTelemetry observability, and Prometheus/Grafana monitoring. You bring the intelligence. We bring the infrastructure.
Individual
Enterprise
Identity & access
Authentication, directory integration, role-based access control
Account-level
Azure Entra ID — OIDC federation, JWT validation, tenant RBAC
Policy enforcement
How agent behaviour is constrained and audited
User-configured Preflight
Palisade — org-wide PACT policies across every user and agent
Audit & compliance
Traceability and tamper-proof record keeping
—
Ed25519-signed receipts in append-only WORM logs. Cannot be modified or deleted.
Tenant isolation
Data and session boundaries between users
—
Scoped data, credentials, sessions, and governance. Users see only what they should.
Backend infrastructure
What runs behind the desktop agent
Managed cloud
AKS — 24+ Go microservices, Istio, ArgoCD, Azure Front Door, Postgres, Redis, NATS
User experience
What changes when switching to enterprise
Standard
Identical app, identical UX. Governance boundary changes. Product does not.
Model provisioning
How AI models are connected at org scale
BYOK per user
BYOK per user + shared tenant models provisioned org-wide. Both paths simultaneous.
Enterprise-grade security, compliance, and infrastructure — without forcing your team onto a different product.
How Actions Happen
Observe. Act. Verify. Improve. Sign.
Cuttlefish does not guess. It reads the live state of the interface, the current objective, and all relevant context before it chooses a path. It acts across browser, desktop, shell, files, and its own UI. It verifies the outcome against the goal. It improves through memory and repeated use. And every meaningful step produces a signed, tamper-proof receipt.
Observe
Read the live DOM, application state, world model, prior context, and the user's current objective before deciding what to do.
Act
Execute across browser tabs, local files, shell commands, generated canvases, its own interface, and any surface the task requires.
Verify
Confirm the intended outcome was actually achieved. Check the real state, not just the model's claim.
Improve
Strengthen repeated workflows as memory, preferences, and route knowledge accumulate over time.
Sign
Issue a cryptographic receipt for every consequential action. Policy evaluation, approval chain, and outcome — all provable.
That is the difference between generating suggestions and carrying real work to completion.
From Personal Use to Organizational Deployment
Choose how you want to run it.
Install Cuttlefish on your computer. Connect a model provider. Start working. When the needs grow — identity, policy, approvals, retention, audit — bring the same product under organizational controls. No migration. No retraining. No different interface. The governance posture scales. The product stays the same.
Personal
Your models and API keysConnect your own models and API keys
Full local executionDesktop, browser, and file access with persistent memory under your direct control
Governed from day oneGoverned execution with cryptographic receipts from the first action
Long-horizon missionsRunning on your machine, across days and weeks
Enterprise
Azure Entra IDIdentity and RBAC for your entire organization
Centralized PalisadePolicy enforcement across every user and every agent
Signed audit trailsWORM retention for full compliance-ready provenance
Multi-tenant isolationTenant-scoped data, credentials, and sessions
Shared tenant models + BYO-AIBoth paths work simultaneously
Production AKS backendFull observability with OpenTelemetry, Prometheus, and Grafana
One product. Personal freedom or organizational discipline. You choose.
Start Now
Personal
Run it yourself.
Install Cuttlefish, connect your API key, and get to work. Your models. Your files. Your browser. Your audit trail.
Install
Download and run the installer. No Docker needed.
Connect
Add your API key from any of 10 supported providers or local models.
Work
Enjoy Cuttlefish!
Enterprise
Bring it under organizational control.
Add identity, policy, approvals, and audit retention. Same product. Same user experience. Enterprise governance.