The Agent

The agent is the reason Qubis is not just an editor with a 3D view. It reads your files, runs commands, drives the solvers, and writes results back — inside the workspace you attached, under permissions you set.

The composer

Everything you send starts in the composer at the bottom of the chat column.

Press Enter to send. Paste an image with ⌘V and it is attached to the message — useful for a screenshot of a drawing, a plot, or a spec page.

When the credits run out

Spending the organization's AI credits does not throw you out of the thread. The transcript stays where it is and the composer closes: where you would type, it names the step that reopens it — Subscribe to keep chatting, Buy credits to keep chatting, or Get more credits to keep chatting where neither is available on its own — and Send is disabled.

A bar sits above it saying why. If you administer the billing it reads You're out of AI credits. with that same step as a button. A member who does not administer it gets Your organization is out of AI credits. Ask an admin to add more. with no button, and the composer reads Chat resumes when your organization has credits.

Anything else that blocks the agent keeps the full access notice rather than this bar, and the notice carries the step that clears it beside Refresh: Finish setup for an account whose setup is unfinished, Choose organization where none is picked, Subscribe for a lapsed plan, and Open Subscription for an admin who has reached their own monthly limit. A member with nothing to act on gets Refresh alone.

Pressing Send on a thread with no folder attached, with something written, opens the workspace picker rather than doing nothing.

Mentions and slash commands

Typing @ opens a picker for files in the workspace, so you can point the agent at something precisely instead of describing it. Typing / opens the command popup. Both are navigated with the arrow keys, and Enter accepts.

Reading a transcript

The transcript is not just prose — it is a record of what the agent actually did.

• Response text streams in as the model produces it.
• Thinking rows show reasoning, when the model produces any. The glyph style is configurable in Settings → Agent.
• Tool rows show each call: what it ran and what came back. Click a row to expand it. Where the result is structured data — a connector (MCP) tool, a browser call, a web extract, crawl, map or research call, or a tool Qubis does not recognise — the expanded card shows a short preview of it rather than the whole payload, and the call's arguments stay folded behind Input. View raw input/output shows both in full, Show preview folds them back, and Copy raw output puts the result on the clipboard byte for byte. A failed call that is not a connector tool shows the preview but no raw controls. A result too big to preview reads Large result — view raw output; one that has not arrived yet reads Waiting for result….
• Sub-agent rows sit where the agent dispatched one, reading Ran agent, then its accent dot and codename — a scientist's name, stable for that agent wherever it appears — then the task title, its live status, and its usage and elapsed time. Clicking one opens it in the Agents pane; a copy button trails it once it has output. Two or more in a row whose sub-agents have all finished fold into one line — Curie, Noether and Turing finished — which clicking unfolds. A run that is still going never folds.
• Reports from a sub-agent are labelled by who sent them — Message from "Fit the bracket" · first line — in that sub-agent's accent, as are "…" finished, went idle, failed and was stopped.
• Approval cards appear inline when the agent needs permission.
• Question cards appear above the composer when the agent asks you something, and the agent waits for the answer. Pick an option, type in the composer, or skip — see Shortcuts.

By default a run of uninterrupted tool activity collapses behind a single expandable summary row, so a long sequence of reads does not bury the narrative. Turn that off in Settings → Agent if you would rather see every row inline.

Interrupting

• ⌃C always stops a streaming response.
• Esc does too, if you enable it in Settings → Agent. It is off by default so that Esc keeps its normal meaning everywhere else.

Interrupting stops the turn. Anything already written to disk stays written — interrupting is not an undo. Check the diff after an interrupt.

Math in chat

Qubis renders inline math with $...$ or \(...\) and display math with $$...$$ or \[...\]. Math inside code spans and fenced code blocks stays literal, as do escaped dollar signs. This rendering applies to agent chat; other Markdown surfaces are unchanged.

What the agent can do

Beyond reading, editing, and running commands, the agent has tools specific to Qubis and to engineering work.

Driving the app

The agent is told to link its work rather than open it: a file it names comes as a link — [bracket.step](cad/bracket.step) — and clicking it opens the file here, so your screen stays where you left it instead of jumping to whatever the agent touched last. A link opens only when it points inside the project, however it is written — relative, absolute, or as a file:// URL. The app still moves when you ask it to: prism_open_file is for "show me the result", and for the skills that open something as part of their own flow.

Handing you a file

send_user_file hands you a file rather than telling you where it wrote one — a report it just typeset, a CSV of results, a plot. It is a compact Sent row in the transcript, with a card under it carrying the name the file was sent as, its size and the agent's caption, and an Open button. Open fetches the file and opens a copy in a tab; while it is fetching the card reads Downloading…, and one card downloading never blocks another. A file past its seven days cannot be fetched again: pressing Open leaves the card reading Expired. Anything else that goes wrong reads as failed, with the reason. The copy is written to Qubis's cache folder rather than into your project, so nothing appears in your workspace or in git status.

The file travels with the thread, so your other clients — the phone apps — offer it too, and a reopened thread still shows the card. It is gated as a read — see Permissions & Approvals.

A file can be up to 30 MiB, a thread holds 300 MiB of them, and a sent file is kept for seven days before it is deleted — long enough to pick it up on another device, not a place to store anything.

Running Python

The agent writes Python through this tool rather than calling python in the shell, so it runs in the managed environment — Python 3.12 with numpy, scipy, pandas, matplotlib, pyvista, CoolProp, Cantera, gmsh, build123d and bd_warehouse — from the project root, and never touches your own Python setup. It takes an inline script, saved under .prism/py/, or the path of a .py file in the project, and returns the tail of stdout and stderr, a traceback on a nonzero exit, and a structured result if the script writes JSON to the file named by PRISM_RESULT_PATH. A run is stopped at 30 minutes.

A script that needs something the environment does not pin gets it for that run: the agent names extra packages, or points the tool at a requirements.txt in the project. What it asked for is saved beside the script under the script's own name — solve.py gets solve.prism-python.json — and re-running the same path reuses it. Where the managed environment cannot serve the task at all, the agent works in the project's own environment through the shell instead — see the managed Python environment.

CAD and geometry

The run returns build metadata such as volume, bounds, and mesh counts, plus the tail of anything the script printed. Its outputs land in .prism/hw/ as model.py, model.step, and model.msh, which the next run replaces — pass a name to write <name>.py / .step / .msh instead, so a variant you want to keep or compare survives later runs. To review shape and placement, open the result in the 3D viewer; prism_set_camera and prism_export_view can help inspect and capture it.

The four prism_cad_viewer_* tools read the CAD viewer rather than change it — which is what lets you select a face and say "what is this?" without describing it. You get a body's name and bounds, a face's surface kind, area, centroid and normal, and an edge's length and end points. They read the viewer you are looking at, so they keep working after the agent opens another file, and unlike prism_set_camera they neither move nor reveal a tab. Entity ids are per-load: #face=17 is good until that file is reloaded, so quote it back in the same breath, not tomorrow. Qubis does not provide automated interference or DFM checks.

Analysis

Solvers

prism_solver_status, prism_solver_daemon, prism_solver_install, prism_solver_run, prism_solver_runs, prism_solver_logs, and prism_solver_cancel drive navier-solverd — see Solver Desk.

Solver runs and Ferro solves are background tasks: completion arrives as a notification in the thread, so the agent never polls for a result.

Sub-agents and background work each get a chip above the composer. The sub-agents chip — 2 subagents, 1 running, or 2 subagents, both finished — opens the Agents pane, where they are listed and each one has a page; it stays until you clear them there. The background-work chip — 3 solver tasks, 2 running · 1 background command — unfolds a card above the composer, with a section for each kind of work present:

• SOLVER TASKS — solver-daemon runs with their state, queue reason, and elapsed time; Ferro solves with their phase and progress; runtimes still installing; submits still in flight. A run Qubis has accepted but has no status for yet reads Accepted · awaiting status. If a finished result could not be handed back to its agent, the header offers retry handoff.
• COMMANDS — the shell commands the agent left running, each with the last line of its output. One that has finished while its result is still reaching the agent is counted in a footer instead. If the thread loses its link to the agent service the rows go with it: reopen the thread to reconnect, and stop still cancels the commands running locally.

Each row that can be ended on its own carries a stop: it cancels that solver run, Ferro solve, or command and reports the cancellation to the agent as that task's outcome, leaving the turn and the rest of the work running.

Your other threads

A main agent can reach your other conversations. list_threads lists your other top-level threads, newest activity first, with whether each is running or idle; search_threads finds one by title, optionally narrowed to threads active within so many days or to a run state; and send_thread_message sends one of them a message. Sub-agents have none of the three, and a thread cannot message itself, a sub-thread, or a thread outside the organization it belongs to.

The message arrives on the other thread as a turn of its own, so it wakes an idle thread rather than waiting for you to open it. In the transcript it reads Message from thread "title" · first line, in the sending thread's accent, the same way a sub-agent's report is labelled by who sent it. The rows for the three tools read Listed threads, Searched threads and Messaged thread.

The agent can also start a thread itself, and here sub-agents can too. fork_thread branches the conversation it is in at the call it is making, carrying the history up to there, the model, the effort and the attached plugin servers; it is titled title (fork) unless the agent names it. create_thread starts an independent one instead, with a title and an opening message, and no history at all. Either way the new thread is a top-level thread of your own: it shows up in the thread list, it works in the same folder — the same worktree, where the source has one, rather than a copy of it — and nothing it does afterwards reaches the conversation it came from. This is not the Fork on the thread's right-click menu, which is yours to press, copies the worktree, and stops at the last settled turn.

Deliverables

PowerPoint decks come from the presentations skill, which writes a slide plan and runs its own generator over it. Reports, trade studies, and memos come from engineering-reports, which writes the document against a house template and compiles it to PDF.

Everything else

The agent also has the ordinary set: file read/write/edit, shell, search (ripgrep and fd ship with Qubis), and the embedded browser — see Agent control for what it can do there. Plugins add more — see Plugins & MCP.

Models and effort

Settings → Agent controls which models appear in the picker, which one is the default, and the default reasoning effort.

• Enabled models — trim the picker to the ones you actually use. If none are selected, all available models are shown.
• Default model — what a new thread starts on.
• Default effort — how much reasoning to spend. Effort ladders differ per model, so the setting resolves against whichever model is active.

Higher effort costs more tokens and takes longer. It is worth it for case setup, debugging a failed solve, and anything where being wrong is expensive. It is not worth it for "what does this file do".

A sub-agent inherits the thread's model and effort unless the agent asks for something else when it dispatches one, so raising effort on a thread raises it for the work that thread fans out too.

Switching model mid-response

Picking a different model while a response is streaming applies straight away and does not interrupt it. The turn already running finishes on the model it started with, and everything after it is the new model's — anything queued behind the current turn and anything you Steer in alike.

Changing only the effort does not interrupt anything either.

One switch can cost you work. Models fall into three groups — the OpenAI ones, the Anthropic ones, and everything else — and crossing between groups while a run of tool calls is still going rewinds the thread to your message and starts that work over on the new model. What the tools already wrote to disk stays written, so expect some of it to be redone. A switch within a group carries on where the last model left off.

Switching models can also move your effort setting. Effort ladders differ per model, so when the new model cannot offer the level you were on, Qubis resolves it to that model's default rather than leaving an effort it does not have.

Project memory

The agent keeps a small Markdown document of notes per project, and reads it at the start of every turn. It is what stops you re-explaining, in each new thread, that this repository solves in millimetres or that you always want the coarse mesh first.

It is always on — there is no toggle. What goes in is meant to be narrow: durable preferences, corrections you have made, and decisions worth carrying forward. The agent is instructed to keep secrets, transient task state, and anything plainly readable from the code out of it, and to ask before saving something it merely inferred — but that is guidance it follows, not a filter Qubis enforces. Ask it to remember something and it writes it immediately.

There is no Settings panel for the notes, and the file's location is keyed to the project rather than named after it, so the way to see or change what is saved is to ask: tell the agent to show you its project notes, or to clear them.

Two things worth knowing:

• A hand edit takes effect on your next message. The agent is given the notes afresh each turn, so an edit does not wait for a new thread.
• They live on this computer, not in your project. The file sits in Qubis's own application-data directory, keyed to the project, so it is never committed and does not travel with the repository. Notes are capped at 64 KiB.

The agent's reads and writes of the notes do not appear as tool rows in the transcript, so a thread where it saved something looks no different — ask it what it has saved rather than looking for the call.

Skills

Skills are workflow guides the agent loads on demand — how to configure a Ferro case, how to drive the solver daemon, how to set up a multi-region CHT case. They ship with Qubis and you can write your own. See Skills.

What it is not

• Not a sandbox. The agent runs on your machine with your permissions. The permission model is what stands between it and your filesystem — configure it deliberately.
• Not deterministic. The same prompt twice can produce different work. Review the diff.
• Not a substitute for engineering judgment. It will happily solve the case you described, including when the case you described is wrong. Units in particular are yours to check.