Chat, Work, or Code: Choosing Your AI Interface¶
The same model behaves very differently depending on the room you put it in. A web chat, a working session, and a code agent can all run the identical frontier model, but the interface decides what the model can actually do, how much of your material it can see, and what the work costs. This page explains the three kinds of artificial intelligence (AI) interface, what a tool call is, why letting a model run tools on your machine is substantially cheaper for heavy work, and how to equip a computer so an agent can do real work on it.
This page is not about running models locally
Everything here uses cloud models; what runs locally is the tools they call (file readers, document converters, compilers). Running the models themselves on your own hardware is a different topic with its own trade-offs: see Running Models Locally.
The Five-Minute Version
Web Chat, Working Session, or Code Agent¶
Web chat (chatgpt.com, claude.ai) is a conversation. You paste or upload material, and the model mostly replies with text. It is the right tool for questions, drafting, and thinking out loud, and the wrong tool the moment the work involves files, revisions at scale, or verification.
Working sessions are the middle tier: Claude Cowork and ChatGPT Work take a task rather than a message, plan it, execute it over minutes, and hand back finished artifacts: documents, spreadsheets, slide decks. Anthropic's own advice is short: "Switch to Claude Cowork when you want to hand off a task." In the desktop apps, both can work in folders on your computer with your permission; started from the web or a phone, they run in the company's cloud. Where each one runs, and on which plans, is on the company pages: Cowork and ChatGPT Work.
Code agents are the deepest tier: Claude Code (the terminal, extensions for code editors, a desktop app, or the web) and Codex mode in the ChatGPT desktop app. These work directly in a folder you open for them: reading files, editing them in place, and running commands, with every consequential action gated by a permission system. Despite the name, code agents are not only for code: anything that lives in files (a course folder, a set of readings, a slide deck) is their territory. Google and xAI make agents of the same kind, and each company page profiles its own: ChatGPT (OpenAI), Claude (Anthropic), Gemini (Google), and Grok (xAI).
| Web chat | Working session | Code agent | |
|---|---|---|---|
| You provide | Pasted text, uploads | A task and files or folder access | A folder on your machine |
| It produces | Text in the chat, and files when file creation is on | Finished documents, sheets, decks | Edited files, run commands, results it has checked |
| Sees your files | Only what you paste or upload | Uploaded or permitted files | The folder you opened, on demand |
| Runs tools | Some, in the vendor's cloud (web search, and file creation where it is switched on) | Yes, on your computer or in the vendor's cloud | Yes, on your machine |
| Effort control | A model and effort menu; the levels vary by plan | Model and effort selection on paid plans | Full effort dial |
| Best for | Questions, drafts, exploration | Deliverables from your materials | Heavy, multi-step, verifiable work |
What a Tool Call Is¶
A tool call is the model pausing text generation to request an action: read this file, run this command, search this folder. The interface executes the action (asking your permission where it matters, in a mode that asks you), returns the result, and the model continues with that result in hand. That loop, repeated, is what makes an agent an agent.
The tool call loop
Model (cloud)
decides what it needs
Interface
permission check
Tool (your machine)
reads, converts, runs
Result returns to the model: only the 30 lines that matter enter its context.
Generation pauses, the action runs, and the model continues with the result in hand.
Why Local Tools Save Inference¶
Model output is the expensive part: every word a model generates is paid inference, whether by tokens or by your plan's usage limits. Tool calls move work off the meter in three ways.
Deterministic work runs on your processor, not the model's. Ask a chat interface to reformat a 40-page document and the model must regenerate every word of it as output. Ask a code agent and it writes a 30-line script; your computer does the conversion in a second, at no model cost. The model's output was 30 lines, not 40 pages. The same logic covers converting files, renaming figures, extracting tables, and running statistics: anything with a right answer a program can compute should be computed, not generated.
The model reads what it needs, not what you have. In chat, context is whatever you paste, usually whole documents. An agent searches the folder and reads the 30 relevant lines from each file. You get better answers (context quality is the main lever) while consuming a fraction of the input budget.
Verification is nearly free. An agent that just edited a file can run the checker, read the one-line result, and fix what failed, in a loop, until the work is actually correct. Each round costs a command execution and a few lines of output rather than a full regeneration. This is why agent-produced work can arrive verified, which is the real difference between the tiers: chat gives you text that looks right, agents can give you work that was checked.
The practical rule: the heavier and more file-bound the task, the further right you should move in the table above. A question costs the same everywhere; a hundred-file revision is affordable only where tools are.
Dialing Effort¶
The agents, and most chat apps, now expose how hard the model thinks as a setting, and it is the most direct cost and quality lever you have. The levels on offer depend on the company, the model, and your plan; some agents add a fast mode, at a higher price, for quick turnarounds, and some a setting that splits a large task across helpers working in parallel. Each company page shows its own levels, with a worked example of the agent's effort command: Codex, Claude Code, Antigravity, and Grok Build.
The heuristic: default effort for routine work; drop effort for mechanical batch tasks where the steps are obvious; raise it only for the genuinely hard steps: architecture decisions, subtle debugging, analysis where a wrong answer is expensive. Effort applies per task, so one session can dial down for the cleanup and up for the hard part. Paying maximum reasoning for routine file renames is the agent-era version of leaving the lights on.
The Models Inside¶
Each interface runs mostly its own company's models, from a top model for the hardest work down to faster, lower-cost tiers for everyday tasks, and which one you meet depends on your plan and on the part of the app you use. Model names go stale faster than anything else on this page, and the interfaces will outlive the models in them, so the names live on the company pages, each with a dated table of the current models, what each is best for, and where you get it: ChatGPT (OpenAI), Claude (Anthropic), Gemini (Google), and Grok (xAI). The Claude page also explains why a request about biology can switch to an older model partway through a session, which researchers working with biomedical material should expect to see. For how the models compare on independent tests, see Compare Models.
Equipping the Machine¶
An agent is only as capable as the tools on the computer it works in. The pattern to know: you do not need to guess what to install, because the agent will tell you. Give it a task, and when it hits a missing tool it will name the exact package and the install command; install once and every future session benefits. A development task will have it request a compiler toolchain and software development kits; a document task will have it request the converters below.
This starter set covers most academic document work, and each item is something an agent can drive without you learning it:
The toolkit, for people setting up an agent
| Tool | What it unlocks for the agent | Windows (winget) | Mac (brew) |
|---|---|---|---|
| LibreOffice | Convert Word, Excel, and PowerPoint files to PDF; open legacy formats; render documents so the agent can visually verify its own edits | winget install TheDocumentFoundation.LibreOffice |
brew install --cask libreoffice |
| Poppler | Read and render PDF pages, extract text | winget install oschwartz10612.Poppler |
brew install poppler |
| Pandoc | Convert between document formats (Markdown, Word, HTML) | winget install JohnMacFarlane.Pandoc |
brew install pandoc |
| Python | Data work, scripting, document surgery | winget install Python.Python.3.13 |
brew install python |
| Node.js | Generate Word and PowerPoint files programmatically; web tooling | winget install OpenJS.NodeJS.LTS |
brew install node |
| Tesseract (optional) | Read scanned documents (optical character recognition) | winget install UB-Mannheim.TesseractOCR |
brew install tesseract |
| ImageMagick (optional) | Convert and resize images in bulk | winget install ImageMagick.ImageMagick |
brew install imagemagick |
All commands verified July 2026 (winget ships with Windows 11; Homebrew is the Mac equivalent). After installing, restart the terminal or app so the new tools are visible. On university-managed machines, installing software may need help from Information Technology (IT); on a personal machine you can install the toolkit yourself.
Choosing What the Agent Can See¶
An agent can read anything in the folder you open, so choosing the folder is how you decide most of what reaches the model; apps you have connected, such as email or a cloud drive, and a signed-in browser you let it use widen that view. A folder scoped to the task keeps the agent's searches quick and its answers focused, and it means material the AI Responsible Use Policy keeps out of publicly available tools, such as patient or student records, is not read along the way. In a mode that asks you, consequential actions prompt for your approval, and that check is enforced by the interface software rather than left to the model's judgment; some agents now start in an automatic mode instead, where a second AI model reviews requests in your place. The AI Agents guide covers the rest of what is worth knowing (actions that cannot be undone, and prompt injection) and profiles each agent and its maker. When you are ready to try one, Your First Agent Session walks you through twenty minutes on a folder of copies.
Next: Your First Agent Session.
Content last reviewed October 8, 2026. Review dates are maintained as described on the About page.