Inline AI in the Code Editor

Circuitry's code editors ship with two AI features that work directly inside the editor: ghost-text inline completion and the Cmd+K inline prompt. Both work everywhere the code editor appears — the standalone code editor, linked code editor, code-node config fields, the markdown prompt of an Agent node, the JSON config of a DataViz node, and remote files opened from a Code File node.

Inline AI is the surgical-control half of orchestrating AI in Circuitry. Use the agent chat for whole features; use Cmd+K and ghost text when you know exactly what you want changed at exactly this line. Both go through the same diff-approval surface, so nothing lands without your sign-off.

Ghost-text inline completion

As you type, a greyed-out suggestion appears at the cursor showing what the AI thinks comes next.

It's off until you switch it on. Every other AI feature in Circuitry is something you ask for — you run a step, you press Cmd+K, you send a message. This is the only one that fires on its own, and on a cloud model that means it can spend while you're still deciding what to write. Turn it on in Settings → Inline AI, from the switch in a code editor's status bar, or by ticking AI suggestions while typing in a Code or Agent step's settings.

• Tab — accept the entire suggestion
• Cmd+→ (Mac) / Ctrl+→ (Windows / Linux) — accept just the next word
• Esc — dismiss
• Any other keystroke continues editing and discards the suggestion

When you hover the suggestion you'll see a small toolbar — ◁ 1/1 ▷ Accept Tab Accept Word ⌘→ ⋯ — that exposes the same actions.

• What it's good at: finishing function bodies you've started, completing the next obvious statement, filling in code from a comment ("// sum the price column" → followed by working code).
• Which model: whichever you've set as your default model. If that's a local, command-line or on-device one, suggestions run on your own machine — nothing reaches our servers and nothing is charged. You can pin a different model to this feature alone (see Settings below).
• Workflow-aware bonus: when the editor lives inside a Code node downstream of (say) a DataGrid, the completion knows the actual column names of the upstream data. Type // sum the price column and the model writes code referencing the real price field, not a guess.

Quick toggle in the editor footer

There's a one-click on/off in the editor's status bar (the same row that shows language and "Modified"). The icon is a small AI-sparkle next to a Tab arrow. Click it to silence ghost text while you focus, click again to bring it back. The button stays in sync with the master toggle in Settings.

Per-step toggle

Steps on the canvas have no status bar — there isn't room for one — so the switch lives in the step's settings instead. Open a Code or Agent step's Configure panel and tick or untick AI suggestions while typing. It shows you what's actually happening for that step, so it stays unticked while suggestions are off app-wide; ticking it switches on whatever was in the way. Unticking only affects that one step, takes effect immediately, and follows the step into its docked side editor.

Cmd+K inline prompt

Press Cmd+K (Mac) or Ctrl+K (Windows / Linux) at the cursor. A small floating box appears anchored to your cursor line. Type a natural-language instruction and the AI generates code at that location.

• With text selected: the AI's output is staged as a diff. Accept or reject hunks the same way you would for an agent edit. ("Convert this to async / await" — review three line changes — accept.)
• No selection: the AI inserts at the cursor. Press Esc to revert if you don't like it; otherwise the insertion sticks.
• While streaming: a Stop button cancels the in-flight request without losing your prompt text.

Settings

Open Settings → Inline AI to configure both features.

Enable in workflow nodes

A single cross-feature toggle at the top of the panel. On by default — both ghost text and Cmd+K work inside the small code editors hosted by workflow nodes (Code / Agent / Data Viz / Code File) just like they do for full file tabs. Turn this off if AI suggestions feel intrusive on the canvas; file-tab editors keep working either way.

Enabled

Off by default, for the reason above. Switching it on here switches it on everywhere a code editor appears; the per-step tick box and the editor's status-bar switch write the same setting.

Suggest in agent prompts

Off by default. An Agent node's prompt is writing, not code, and it's the one editor you may sit in for several minutes without ever running anything — so suggestions there fire constantly, guess at intent they can't know, and on a cloud model cost something at every pause. Turn it on if you want prompt suggestions; code editors are unaffected either way.

Enabled / disabled (per feature)

A master toggle for ghost text, and a separate one for Cmd+K. Off = nothing fires, no requests, no UI.

Model

Three options:

• Use my default model — the standard setting. Follows whatever you've picked as your default model, so suggestions run wherever the rest of your work runs. If that model is local, command-line or on-device, they cost nothing at all.
• Use chat agent — the inline AI tracks whichever model the chat panel currently has selected. Switch your chat to a different agent and inline AI follows automatically. Best when you want one consistent agent across everything.
• Use a dedicated model — pin a model independently of chat. The picker exposes every model the chat panel can use — including OpenAI / Anthropic cloud models, local LM Studio / Ollama models, Apple Intelligence (on-device), and CLI models like Claude Code. Models good for low-latency completion are flagged "fast" in the dropdown; nothing stops you from pinning Opus if you want, it just costs more and feels slower.

Defaults: both follow your default model. Pin a dedicated one if you want suggestions on something smaller and faster than whatever you use for everything else.

Disabled languages / files

Two lists per feature. Don't fire in (e.g.) markdown or plaintext, or in /path/to/some/generated.ts. Useful for files where suggestions get in the way — generated code, log files, READMEs you're hand-writing.

Keyboard shortcuts

All shortcuts are reconfigurable. Open Settings → Keyboard Shortcuts, find the Inline AI category, click any binding to capture a new key combo. Defaults:

• Tab — accept the entire ghost-text suggestion
• Cmd+→ / Ctrl+→ — accept just the next word of the suggestion
• Esc — dismiss ghost text / close Cmd+K / stop streaming
• *Alt+* — force-trigger ghost text (when it didn't appear automatically)
• Cmd+K / Ctrl+K — open the inline prompt at the cursor / selection
• Enter — submit the inline prompt (Shift+Enter inserts a newline)

What it costs, and what your plan includes

Ghost text and Cmd+K need cloud AI, which paid plans include and the Free plan doesn't. On Free the settings stay visible but nothing fires — with one exception: a model running on your own hardware (a local endpoint, a CLI tool, or Apple Intelligence) costs nothing to serve, so it works on every plan. Turn on Use my own model under ghost text to allow it; it's off by default only because we can't judge whether a given endpoint is good enough at this to be worth the interruption.

Nothing is charged when the model is yours. If your default model is a local endpoint, a command-line tool or Apple Intelligence, suggestions are sent straight from your machine to it — they never pass through us, so there's nothing to bill and nothing to gate. That's true on every plan.

On a platform model, each suggestion is a small charge and appears in Usage & charges as Code completion (Cmd+K appears as Inline edit), so it's separate from the runs you started yourself. Circuitry is careful about how often it asks: only after you pause, one request per burst of typing, and carrying on typing refines the answer already asked for rather than buying another. Returning to somewhere it has already looked reuses that answer instead of paying twice. If your balance runs out, suggestions go quiet on their own and come back after a top-up.

The old separate switch for "use my own model" is gone — there's nothing left to opt into. Set the model you want as your default and suggestions follow it.

Privacy and which model your code goes to

The dedicated-model picker shows the same model list the chat panel uses, so the privacy story is the same. To keep code on-device, pick Apple Intelligence (Mac / iPad) or any local model you've configured (LM Studio, Ollama). Cloud models route through Circuitry's server-side key injection — your API key isn't exposed to the browser, but the prompt does leave your machine. CLI models (Claude Code) talk to the CLI process you've configured locally.

Ghost text follows your default model, so choosing an on-device or local model as your default keeps completions on your machine too.

What's distinctive

Inline AI covers the table stakes you'd expect — ghost-text completion, a natural-language Cmd+K prompt, diff-accept on a selection, and fully reconfigurable shortcuts. Two capabilities are unique to Circuitry, because only Circuitry connects code editors to data flows:

• Workflow-aware completion — when the editor lives inside a node, completions know the actual shape of the upstream data (real column names, not guesses).
• Editor-in-graph — the same inline AI runs in the small code editors embedded on the workflow canvas, not just in full file tabs.

You can also keep code on-device by pinning Apple Intelligence or a local model for either feature.