Why local AI keeps your code private

Ask a cloud AI to refactor a function and your code leaves your machine. It crosses the internet to a server you don't control, gets processed, and the answer comes back. Ask a local AI to do the exact same thing and none of that happens. The workflow looks identical. The data path isn't even close. This is what that difference actually buys you for code privacy.

What "your code" means in this context

"Your code" is bigger than the snippet you pasted. In a real AI coding session it usually means:

• The prompt you typed. That text can carry credentials, customer names, or business logic.
• Whatever files the agent read while working, which is often most of a feature or an entire module.
• Shell output the agent chewed through. Think environment variables, log lines, error messages with PII baked in.
• The conversation history, because the next turn refers back to it.

Every cloud call ships some slice of that. A tool that swears it "only sends prompts to the cloud" is still sending prompts stuffed with your code excerpts.

The cloud path

Walk through one refactor on a cloud tool and here's the trip your code takes:

1. You select a function locally.
2. The tool wraps it in a prompt along with project context, often dozens of files.
3. That prompt gets sent over TLS to the provider's API.
4. Their inference server processes it and may log it. Most keep prompts around for a while for abuse monitoring, sometimes for training.
5. The response comes back.
6. The conversation may stick around on the server so you can resume it.

The reputable providers like Anthropic and OpenAI publish real policies about what happens to prompts, and enterprise customers can usually opt out of training. Fine. But the data still physically crosses someone else's network and sits on their disks for some stretch of time. In healthcare, finance, defense, or legal, that alone is often enough to make cloud AI either flat-out banned or so heavily reviewed it stops being worth the friction.

The local path

Same refactor, local tool. The trip is a lot shorter:

1. You select a function locally.
2. The tool wraps it in a prompt.
3. The prompt goes to the inference runtime running right there on your Mac.
4. The model weights, loaded straight off your disk, process it in your unified memory.
5. The response comes back.
6. The conversation gets written to ~/.outlier/ on your disk.

Zero external calls. Nothing third-party ever touches the prompt or the response. Pull the plug on your network and the whole thing keeps running.

Where local tools do still talk to networks

Let's be straight about it. Local tools do hit the internet for a few things. None of them involve your code:

• Initial model download. The first time you use a model, its weights come down from HuggingFace. Once they're on disk, inference needs no network at all. Outlier grabs Nano (~3 GB) on first launch and pulls bigger tiers only when you ask for them.
• App updates. The app checks for new versions now and then. You can switch that off.
• Website analytics. The marketing site runs Plausible, which is privacy-friendly and cookie-free. The app itself never phones home with usage data.
• Optional connectors. Opt into a web-search MCP tool, a Slack integration, or some cloud MCP server and those make their own calls, all clearly labeled. They're off until you turn them on.

The verification test

Don't take anyone's word for it. The cleanest way to check whether a local tool really keeps your code local is to kill your Mac's wifi and Bluetooth, then go use it. Chat should work. Agent should work. File edits should work. Project memory should work. Anything that breaks in airplane mode is reaching for the cloud, and now you know exactly which piece.

Outlier passes. Once that first-launch download is done, the whole inference, agent, and memory workflow runs with the network completely off.

Where this matters most

For some work, local AI isn't the nice-to-have option. It's the only one. Two kinds stand out:

• Regulated code. When your contract, your customer agreement, or your regulator forbids handing code to a third-party AI provider, that's the end of the discussion. Think most healthcare PHI, financial trading code, defense contractor work, law-firm document automation.
• Pre-public IP. Unreleased code. Algorithms that are your competitive edge. Your secrets-management implementation. Firing those off to a cloud AI for "just a quick refactor" is usually the exact habit your legal team is begging you to drop.

Outside those buckets, picking local over cloud is really about insurance. Your cloud provider might rewrite its terms next year. A local tool just keeps working, unchanged, on your terms.

Frequently asked questions