5
Tabs: Home, Workspace, Browser, Apps, Settings
Capability reference
Everything Cuttlefish does, in plain language.
Cuttlefish is a desktop AI workspace where you choose the model, work across your real computer, keep your data close, and turn repeated work into apps you own. This page walks through every capability — what you get, and how to use it.
Any model
Cloud or private, switched mid-conversation
Your computer
A real browser, your files, your tools
Proof
A plain record of what happened
The five tabs
One simple shell over a workspace that can actually do the work.
Open Cuttlefish and you find five tabs across the top — that's the whole shell. Everything else is reached from these or appears right when you need it. You don't need a tutorial to start; you start in Home and ask the way you would any assistant.
Home — your assistant conversation
The main conversation, and where most of your day happens. You ask a question and the answer streams back as it's written. When a request needs more than words, Cuttlefish reads a file, looks something up, drafts a message, or uses a connected tool — and shows each step inside the thread as it goes. Anything consequential pauses for a plain yes-or-no first.
Workspace — make anything
A canvas where you build by describing. Ask for a document, a one-page site, a small dashboard, or a working mini-app, and Cuttlefish builds it live in front of you. The preview runs in a walled-off space that can't reach your files or accounts, so you can try anything with nothing at stake, then refine it in plain words until it's right.
Browser — works alongside you
A real, built-in browser with tabs and an address bar — and Cuttlefish can see the page and help on it. It clicks, types, navigates, and pulls out what matters while you watch, with a clear sense of who's driving. You can take the wheel at any moment, and sensitive steps always wait for your OK.
Apps — your own library of tools
The one place that holds everything you've built and connected. Apps made from your own repeated work open here like any other tool, your connected tools sit alongside them, and any app can step out into its own window. Each app keeps a clear record of what it's done, and only does what you've allowed.
Settings — everything you configure
Where you choose models, connect tools, set your privacy, and tune how Cuttlefish works for you. Many of the capabilities you'll reach for most live here or appear contextually — lasting instructions, point-of-work capture, companion windows, and your team or enterprise controls — so the main shell stays calm and uncluttered.
Reached from these five
Companion windows, the mobile companion, generated apps, and the live Freehold estate view all open from the five tabs or run alongside them. You never have to hunt through nested menus; the thing you need surfaces where the work already is, the moment you reach for it.
Environment runtime & manifests
Cuttlefish knows the shape of your machine — and checks it's ready before it acts.
Cuttlefish works best when it understands the computer and tools you actually use. It takes stock of what's installed, what it can reach, and what it's ready to help with, so its help fits your setup instead of guessing — and so it can prove it's ready before it does real work.
Learns the shape of your setup
Cuttlefish builds an honest picture of your available models, connected tools, and what it can do right now. When you ask for something, it already knows what it has to work with, so the help you get reflects how your machine actually looks today — not a generic guess.
Checks readiness, then acts
Before Cuttlefish starts real work, it confirms the pieces it needs are present and reachable. If something's missing, it tells you plainly up front instead of failing halfway through. You get fewer half-finished attempts and clearer answers about what's possible.
A clear declaration of what each app needs
When you build an app, it comes with a plain statement of what it needs to run — which tools, which permissions, which data. Nothing is allowed quietly; an app works inside the permissions you set, and those limits travel with it wherever you open it.
Ambient, quick capture & voice
Get help where the work already is — by hotkey or out loud.
You don't have to stop what you're doing to get help. A system-wide ask bar brings Cuttlefish on top of whatever's in front of you, and you can talk to it and hear it answer back. The help comes to the work, so a quick question stays quick.
Quick capture, on demand
Press a shortcut from anywhere and a small ask bar opens over your current window. Point it at the active window, some selected text, the page you're reading, or a region you draw a box around, and Cuttlefish picks it up. Ask, summarize, explain, rewrite, save it to memory, or turn it into a next step — without losing your place.
A quiet eye, only if you ask for it
An optional watcher can notice when something on your screen meaningfully changes — a build finishes, a status flips, a page you're waiting on updates — and offer a hand at the right moment. It's off until you switch it on, you decide what it can look at, and a single control turns the whole thing back off.
Talk to it, hear it back
With Voice you say what you need out loud and Cuttlefish answers in a clear, natural spoken voice — a real back-and-forth for hands-free work. Your typed conversation and your spoken one are the same conversation, and the microphone is only on during a session you start.
Cuttlefish only looks when you ask. Outside the moment you open the ask bar — or the watcher you turned on — it isn't reading your screen. Sensitive details are blurred out on your own machine before anything goes anywhere, and when you grab a selection it borrows your clipboard for a split second and restores exactly what you had.
Workspace App Foundry
Turn repeated work into real apps you own.
Some work comes back over and over — the same calculator, the same dashboard, the same little form. When you build something good in Workspace, you don't have to keep recreating it. You turn it into a real app that lives in your library and opens like any other tool, every time you need it.
Describe
Build it on the canvas.
Say what you want in plain words and watch it come together live, working as it would for real.
DocumentPageDashboardMini-app
Refine
Shape it in conversation.
Ask for changes the same way — bigger buttons, a dark theme, another column — as many rounds as you like.
Live previewNo codeUnlimited rounds
Verify
Tested in a walled-off space.
Before it becomes yours to keep, Cuttlefish quietly checks it works. You only install it once it passes.
Isolated testPlain notesNo error codes
Install
Open it any time.
It lands in your Apps library and opens with one click — no rebuilding, no re-prompting.
One clickRoll backPlain history
Saving makes a draft, testing is automatic, installing is a separate deliberate click — nothing turns on behind your back.
It opens like any tool
Your new app shows up in your Apps library next to everything else you use. One click and it's open, ready to run again, every time — the workflow you do every week stops being a chore and becomes a button.
Stays a tool, not a back door
An installed app runs in its own safe, isolated space. It can't reach your files or anything else on your computer unless you specifically allow it, and that limit travels with the app wherever you open it.
You can undo a change
Updated your app and liked the old version better? Restore the previous one in a single step. Every version you've installed is kept, so improving an app never means risking it.
A plain history, always there
Every app keeps a clear timeline — saved, tested, installed, updated, restored — in words anyone can read. If you ever wonder what an app does and when it changed, the answer is right there.
The browser that works alongside you
A real browser Cuttlefish can see and act in — while you watch.
Cuttlefish has a full web browser built in: tabs, an address bar, back and forward. The difference from the browser you use today is that Cuttlefish can see the page you're on and help you on it — open a site, click through it, fill a form, or pull out the details you came for — and you can take over whenever you want.
It works on the live page
Ask it to find the cheapest option on a page, fill in a form, or confirm an order went through, and it works on the real page in front of you instead of guessing. When it clicks or types, the spot lights up for a moment so you can follow along.
You decide who's driving
Four plain settings set how much it can do on a page: Manual (read only), Assist (get things ready but stop short of changes), Act (do the steps while you watch), and Approve (do the work, but pause on anything sensitive and ask first). You can change it per page and grab the wheel at any moment.
Teach it once, it repeats it
For something you do every week, record the task once — click here, type this, go there — and Cuttlefish remembers the steps. Next time you just ask it to run, and it walks the same path. Keep a small library of these and replay any of them.
Separate browsing identities
Keep more than one profile — one for work, one for personal, one for a client — each with its own logins and cookies, kept apart. Because it's your real browser, Cuttlefish can help inside accounts you're already signed into, but only when you've said it can.
Apps & companion windows
Your tools in one library — and any of them in its own window.
The Apps tab holds everything you've built and connected, and any piece of work can pop out into its own focused window so you can keep working everywhere else at the same time. Open one window or a wall of them; they behave the same whether you run one alongside your chat or twenty side by side.
A library you come back to
Apps built from your own work, your connected tools, drafts you haven't saved yet, ready-made templates, and an archive for things you've tucked away — all on one tidy shelf. Each app shows its name, where it came from, and whether it's ready, so you always know what you're looking at.
Pop work into its own window
Pop a chat, a workspace, the browser, an installed app, a running task, a coding session, or the live Freehold estate into its own window. Each one stays anchored to its single job — a turn you take in one window never slips into another — and draws on the same Cuttlefish underneath, so it's never less capable, only more focused.
Coordinate, without crossing wires
When two windows are related, you can connect them so they quietly check in and coordinate, surfacing to you only when something needs you. Each window keeps to its lane — a coding window's tools never leak into one that has no business with them — and connecting two windows never lets one borrow the other's permissions.
Your work comes back the way you left it. Close a window and the work behind it keeps going unless you meant to stop it; reopen it later and you're right back where you stood. When the app reloads, your open windows and how each was set up all return — and anything that was waiting says so plainly instead of pretending nothing happened.
Proof & control
The quiet floor that makes the freedom real.
Everything above is worth more because of a quiet floor underneath it. Your data stays where you put it, nothing consequential happens without your OK, and there's a plain, tamper-proof record of what was done. You'll rarely think about any of it — it runs in the background as quiet confidence.
Your data stays where you put it
Local stays local. Nothing goes to a provider's servers unless you choose it, and a private model on your machine keeps the whole exchange — including the context it draws on — on your computer. "Keep this private" stops being a setting you have to trust and becomes a fact about where the work happened.
Nothing changes without your OK
Anything with real consequences asks first, with a plain card showing exactly what it wants to do. You can allow, decline, adjust, or have it do a dry run — and if you walk away, the safe default is to wait. You grant specific permissions, and you can take them back later.
Proof of every action
For anything Cuttlefish does, you can see what it used, what it changed, who approved it, and where the result went — in plain language, kept as a tamper-proof record you can check any time. There's no guessing about what was done on your behalf.
Use any model — cloud or local
The AI is yours, not the app's.
Cuttlefish doesn't hand you one model in one box. You bring the models you want — the big cloud names, the fast and cheap ones, the private ones that run on your own machine — and you choose which to use for each piece of work. You can even switch in the middle of a conversation.
The models you can bring
Connect the major cloud assistants — OpenAI, Anthropic, Google, and Azure OpenAI — plus fast and specialist providers like xAI, DeepSeek, Mistral, and Groq, and private on-machine models through Ollama and LM Studio. A custom connection covers any other model or private setup you have access to.
Switch mid-conversation
You're never stuck with the model you started with. Send the heavy reasoning to a stronger model, drop down to a faster one for routine follow-ups, or move to a private local model the moment the topic gets sensitive. The conversation keeps going; only the model behind it changes.
Private, on your own machine
Run a model directly on your desktop and the whole exchange stays there — your words go to the model on your computer, the answer comes back, and nothing in between ever leaves. Local models hold up well for everyday work, and for sensitive material, "private" means genuinely private.
No lock-in, ever
Your conversations, your memory, your apps, and your work belong to your workspace — not to any one provider. If a provider changes its prices, limits, or terms, you move to another model and keep going. No migration, no export, no starting over.
Memory that learns your work
An assistant you don't have to reintroduce yourself to every morning.
In most AI apps, every conversation starts from zero. Cuttlefish keeps a working memory of your context — the durable facts about your work, the way you like things done, the details you've already shared — and brings the right of it back when it's useful, so the more you work together, the less you repeat yourself.
Remembers what stays true
Your role, the projects you keep coming back to, the people you work with, and your standing preferences — "always summarize first," "I write in British English." A passing comment in one chat doesn't become a permanent rule; lasting facts are weighed before they're kept, so your memory stays clean and trustworthy.
Brings back only what's relevant
Cuttlefish doesn't dump everything it knows into every reply. For each message it pulls in the most relevant remembered context for what you're asking right now and leaves the rest out of the way. Relevance, not volume, is the point.
You can see it and change it
Ask what it remembers about a project, a person, or your preferences, and it tells you in plain language. Correct what's stale, tell it to forget what you no longer want, and tune how much it leans on memory. When you run a private model, the context it draws on stays on your machine too.
My Environment
See exactly what your Cuttlefish is set up to do.
My Environment is where Cuttlefish shows you the picture it has of your setup — your available models, your connected tools, and what it's ready to help with. You don't have to manage it for Cuttlefish to work; it keeps itself current in the background. It's there for the moments you want to see, at a glance, what your machine can do right now.
One honest picture
Open the Apps tab and choose My Environment to look over what Cuttlefish has found. As you connect a new tool, add a model, or change your setup, the picture keeps up — so the help you get always reflects how your machine looks today.
Pairs with your private setup
If you run models privately on your machine, My Environment is how Cuttlefish knows they're available and ready. Your private setup is a first-class part of the picture, not an afterthought — and what Cuttlefish learns about your machine stays with you.
Makes "ready or not" honest
Because Cuttlefish checks readiness first, you get fewer half-finished attempts and clearer answers about what's possible. Nothing in your environment gets used for real work without the usual check-in, in plain language, before anything happens.
Start using it
The conversation you already know, with the walls taken down.
Download Cuttlefish, connect a model — cloud or local — and start in Home exactly as you would anywhere else. Everything on this page reveals itself as you need it.