vertex what's new.

See what you spend, git at a glance, models on your Mac, and sharper tools for the model

• What every reply costs, with /cost

  vertex adds up each reply's own token counts per model and prices them: the provider's own figure when it sends one, OpenRouter's model list, or a price table built into each release. /cost shows this session, today, the last 7 days and the last 30, with cached input counted at its own rate. Local models and Nexus's free tiers show as free, and a reply with no known price shows as unpriced instead of a guess.

  Why it matters. A long coding session on a paid key can cost more than you expect, and the bill arrives later. Now you can see it as you go, and a budget warns you before a day gets away from you.

  How to use it. Type /cost. To set a daily warning, type /cost budget 5; vertex tells you at 80% and again once it's passed. /cost budget off clears it. The records stay on your Mac for 90 days.

• Git and GitHub in the status row

  The row under the input shows your branch, ↑ commits ahead and ↓ behind, + staged, ~ changed, ? untracked and ! conflicts, and the branch's pull request number with ✓, ✗ or ◷ for its checks. vertex looks at git every few seconds and asks the GitHub CLI about the pull request about once a minute, in the background, so typing never waits.

  Why it matters. You see when the model's edits changed files, whether you have work to push, and whether your checks passed, without leaving vertex or running git status yourself.

  How to use it. It's on whenever you're in a git repo. The pull request part needs the GitHub CLI (gh) installed and signed in. /github off stops the gh calls.

• /model as a constellation

  /model draws your models as stars joined by lines, grouped by where they come from. Each one says LOCAL or CLOUD, the one in use is marked, and the effort line sits right under the list.

  Why it matters. Choosing a model and how hard it thinks is one decision, so they now live on one screen, and you can tell at a glance what runs on your Mac and what goes to the cloud.

  How to use it. Type /model. Up and down pick a model, left and right set the effort, Enter makes it your default and s keeps it to this session.

• /effort from faster to smarter

  /effort is a single line from low to max. Its colors warm as you move up, and max shimmers. Ultracode is now a separate switch: every task is planned, done step by step, checked with real runs, fixed and reviewed, at whatever effort you pick.

  Why it matters. Effort decides how deeply the model thinks in each step, and Ultracode decides whether it works through a careful process. Splitting them lets you have a quick model that still checks its work, or a deep thinker that answers straight away.

  How to use it. Type /effort, use left and right to choose, Tab to turn Ultracode on or off, and Enter to keep it.

• A livelier Sputnik

  Sputnik, vertex's mascot, now twinkles and catches a sweep of light. Click it and it waves and throws sparkles, and an about line opens with a docs link you can click. Once it scrolls out of view it stops moving, and vertex repaints the screen only while something on it is moving.

  Why it matters. It makes the welcome card feel alive without costing anything when you're working: no repainting for an animation you can't see.

  How to use it. Click Sputnik on the welcome card. Click the docs line to open the docs in your browser, and click Sputnik again to close it.

• Models on your Mac

  Ollama and LM Studio are now in the provider list. vertex finds the server on your Mac, lists its models and lets you pick one, with no key to paste. The model gets the same tools as any other, so it can read, edit and run commands, and its replies stay on your Mac.

  Why it matters. You can code with a model that costs nothing per reply and never sends your code anywhere.

  How to use it. Start Ollama or LM Studio's server, then /login, pick Ollama or LM Studio, and choose a model. vertex uses the context size the server reports for the loaded model, else 8,192, so raise Ollama's context length for long tasks.

• /rewind

  vertex remembers every file it changed this session, grouped by your request. /rewind lists your recent requests and puts the files back to how they were before the one you pick, removing files that request created.

  Why it matters. If a change went the wrong way, you get your files back in one step instead of undoing edits by hand.

  How to use it. Type /rewind (or /undo) and pick the request to go back to. Changes made by commands aren't tracked, so they stay; the conversation stays too.

• Sharper tools for the model

  The model can now make several edits to one file as a single change with one diff, search with a regular expression, see the lines around each match and limit a search to file names like *.py, and keep a plan as a checklist that you see and that stays with it through /compact.

  Why it matters. Published comparisons of coding assistants show the tools around a model change how often it finishes a task. Fewer, larger edits mean fewer approvals and fewer half done changes, and a visible plan shows you where it is.

  How to use it. Nothing to turn on: ask for work with several steps and the model uses them. Each edit still shows its diff first.

• Your key's models, with their real context

  /model shows the models your key can use with the context size its provider reports, from 8k up to 1M, and the context meter follows the model you pick.

  Why it matters. The context size decides how much of your project the model can hold at once, so it should be the real number for that model, not a guess.

  How to use it. Type /model and look beside each model on your key.

• /model in a short window

  The /model panel takes only the rows it needs and scrolls around your selection, showing how many models are above and below. A key with up to 60 models opens them as a list right away.

  Why it matters. The bottom of the panel, with the effort line and the keys, used to be cut off in shorter windows.

  How to use it. Type /model in any size window and use up and down.

• Commands can't read your tokens

  Commands vertex runs in the sandbox can read only the toolchain folders they need. The folders where tools keep logins, like ~/.cargo/credentials.toml, npm's global npmrc, uv's credentials and git's stored credentials, are out of reach, and a symlink can't be used to reach them.

  Why it matters. Whatever a command prints goes back to the model, so a command must not be able to print a token.

  How to use it. Nothing to do. If a tool you use needs a folder that's now unreadable, open an issue.

• Safer edits

  vertex's file tools refuse .git however it's spelled, and sandboxed commands can't create or write a .git folder anywhere in the project. File writes go through folder handles that refuse links, so a folder swapped for a link can't redirect them. The status row's git switches off a repo's own filters and file monitor and ignores bare repos it wasn't pointed at.

  Why it matters. A repo's config can make git run a program. These close the ways a model, or a file it wrote, could plant one for your own git to run later.

  How to use it. Nothing to do. For extra safety in your own git, you can run git config --global safe.bareRepository explicit.

• Releases named by date

  This release is 2026.10.16, the day it shipped. Every release after it is a later date.

  Why it matters. A date tells you at a glance how fresh your vertex is, and the number always goes up.

  How to use it. vertex --version, or the welcome card, shows it.

• Tips

  While a reply is on its way, a tip shows under the spinner and changes every 12 seconds, and one shows under the welcome card: commands, keys, and where to find the docs and the changelog.

  Why it matters. There's more in vertex than anyone reads in a help page; a tip at a quiet moment is how you find it.

  How to use it. /tips off hides them and /tips on brings them back.

A real sign in, your own API keys, and models by their real names

• A proper sign in screen

  The first time you open vertex you see a Welcome card and nothing else: no chat box, no status row, no half loaded screen. You pick how vertex reaches a model, and the rest of the app appears once that works.

  Why it matters. Before this, a new user landed in a chat that could not answer yet, with no hint about what to do. Now the first thing on screen is the one thing you need to do.

  How to use it. Run vertex. Pick Personal API key and follow the steps. Esc leaves the card, and /login opens it again whenever you want.

• Bring your own API key

  vertex works with a key from Anthropic, OpenAI, Google Gemini, OpenRouter, Groq, Cerebras, Mistral, xAI, Together, DeepInfra or Fireworks, or with any server that speaks the OpenAI chat API over https. vertex checks the key with that provider, lists the models it can use, and lets you pick a default.

  Why it matters. You use the account and the models you already pay for, and nothing sits in between. The key is saved in the macOS Keychain, not in a text file, and it is only ever sent to the provider you picked. If a key looks like it belongs to a different provider than the one you chose, vertex asks before sending it anywhere.

  How to use it. /login, then Personal API key, pick the provider, paste the key, and type a few letters to narrow the model list. Custom endpoint takes any https base URL, like https://host/v1.

• Your key's models in /model, and its limits in /usage

  Every saved key adds a section to /model with your default model on that key and a way to pick from all of its models. /usage shows what the provider reports about that key's rate limits.

  Why it matters. Switching models no longer means re-adding a key, and you can see how close you are to a provider's limit before a reply fails.

  How to use it. /model, arrow to the model and press Enter to make it your default, or press s to use it for this session only. /usage on a personal key shows the requests left in the provider's window as of your last reply.

• Nexus access keys

  Someone who runs a Nexus server (Agent Control) can give you an access key. It is a chat only key: it reaches the models that person chose for it, up to a daily cap, and nothing else on their server.

  Why it matters. You can use a friend's or a team's models without an account and without your own provider key, and the person who runs the server keeps control: they can limit the key to certain models and revoke it any time.

  How to use it. /login, Personal API key, Nexus access key. Type the server address you were given, paste the key (it starts with nxa_), and pick a model. Plain http is only accepted for local network or WireGuard addresses, so a typo can't send the key across the internet unencrypted. /usage shows your requests and tokens against the key's daily cap.

• Cloud models by their real names, and they ask first

  On a Nexus server, the cloud models are listed by what they really are: Qwen 3.8 27B and GPT-OSS 120B on Groq, and GLM-4.7 Flash on Cloudflare. The first time you pick one in a session, vertex asks a two choice question before anything leaves the server's own machines.

  Why it matters. You should know which company runs the model that reads your prompt. A made up tier name hid that.

  How to use it. /model on a Nexus access key shows the server's local models first and its cloud picks under their own heading. Choose one and answer the question that appears.

• Live token count and daily usage

  While a reply streams, the counter under it climbs as tokens arrive. /usage shows today's use (by UTC day) against each limit that applies to how you're signed in.

  Why it matters. You can tell a slow reply from a stuck one, and you see a limit coming instead of hitting it mid task.

  How to use it. Just chat and watch the line under the reply. Type /usage any time.

• A tighter / menu, and Sputnik comes alive

  Typing / opens the command menu right under the input box, sized to the commands that match what you've typed so far. Sputnik, vertex's mascot, now blinks while idle, scans while the model is thinking, and beams while a reply comes in.

  Why it matters. The menu no longer jumps around or covers your conversation, and you can tell at a glance whether vertex is waiting, thinking or writing.

  How to use it. Type / and keep typing to filter, arrows to move, Enter or Tab to pick. /help lists every command.

• Cleaner pastes and sign in

  Pasting many lines keeps a single prompt marker instead of repeating it on every line, and the sign in card now opens over your conversation and closes without leaving any of its text behind.

  Why it matters. Long pastes stay readable, and adding a key mid conversation no longer clutters the scrollback.

  How to use it. Paste as usual. Type /login whenever you want to add or switch keys.

• Safer tool calls, and every Anthropic model

  If a reply stops early (you pressed Ctrl+C, or the connection dropped), any half sent tool call in it is thrown away instead of run. The Anthropic model list now loads in full instead of stopping at the first page.

  Why it matters. A cut off tool call can carry incomplete arguments, like half a file edit. Running it could damage your files. And you can now pick any Claude model your key can use.

  How to use it. Nothing to do. If a reply is interrupted, ask again.

vertex works in your project: it reads, edits and runs code, with you in control

• Works in your project folder

  Start vertex in a project folder and it can read files, search the code, make edits and run commands there, like other coding assistants in the terminal.

  Why it matters. You describe the change in plain words and vertex does the reading and typing, while you stay in your own terminal and folder.

  How to use it. cd into your project and run vertex, then ask for what you want, for example "add a --verbose flag to the CLI and update the README".

• See every change first, and four modes

  Before vertex changes a file you see the diff and choose. Shift+Tab cycles four modes: manual asks before every change, accept edits makes file changes without asking, plan only reads and finishes with a plan, and auto also runs commands without asking where the command sandbox applies.

  Why it matters. You decide how much freedom vertex gets for each task, from read only planning to hands off editing.

  How to use it. Press Shift+Tab to cycle; the current mode shows in the status line. At a change prompt, Yes allows one change and Yes, allow all edits this session switches to accept edits.

• Commands run in a sandbox

  Where macOS's sandbox is available, every command vertex runs goes through it with a profile made for that run: no network, writes only inside the project folder and a private temp folder, never into the project's .git folder, and most of your home folder unreadable. Commands can still read the project, the folders on your PATH, ~/.local, ~/.cargo and your git config, which toolchains need. They can't open other apps or reach the Keychain. Where the sandbox can't apply, vertex says so and asks before every command.

  Why it matters. A model can be wrong, and a command it writes can be wrong. The sandbox limits what a bad command can change and read, so a mistake stays inside the project.

  How to use it. Nothing to set up. vertex refuses to run commands when it was started in your home folder or above it, so start it inside a project folder. Keep tokens out of ~/.local, ~/.cargo and git's config if you run in auto mode.

• Higher effort runs and fixes its own work

  At effort xhigh and max, and with Ultracode on, vertex runs what it built (tests, a syntax check or the program itself) and goes back to fix whatever fails before it calls the job done.

  Why it matters. A change that was never run is a guess. Higher effort trades time for checked work.

  How to use it. /effort and pick a level, or turn on Ultracode in the same box.

• A clearer /model

  /model is a list you move through with the arrow keys. Enter makes the highlighted model your default for new sessions, and s uses it for this session only.

  Why it matters. Trying a model for one task no longer changes what every later session starts with.

  How to use it. /model, arrows, then Enter or s.

• /compact for long conversations

  /compact replaces the conversation so far with a summary, freeing room in the model's context, and vertex does it on its own when a conversation gets close to the limit. For now this works when you chat through a Nexus server (an account or an access key), not yet on a personal API key.

  Why it matters. Long sessions keep working instead of failing once the model runs out of room.

  How to use it. Type /compact any time, optionally followed by what the summary should focus on.

• Ctrl+C twice to quit, and release notes in the app

  Ctrl+C stops a reply, and pressing it twice quits. /release-notes shows the notes for every version without leaving vertex.

  Why it matters. Stopping a reply and leaving the app are different things, and a single stray Ctrl+C shouldn't do both.

  How to use it. Ctrl+C once to stop, twice to quit, or type /quit. Ctrl+D also leaves.

The first full screen vertex

• Sign in with a Nexus account

  People with an account on a Nexus server can sign in and chat through it, with no model keys stored on their own machine.

  Why it matters. The server holds the keys and runs the local models, so a laptop needs nothing but vertex.

  How to use it. Ask the person who runs the server for an account or an access key.

• Model tiers, effort levels and Ultracode

  On a Nexus server you pick a tier (Lunar is fast, Solar is for code, Galactic runs in the cloud) and an effort level from low to max. Ultracode thinks at max, checks its own draft, and then answers.

  Why it matters. Quick questions get quick answers, and hard ones can take the time they need.

  How to use it. /model for the tier, /effort for the level and the Ultracode switch.

• Full screen layout

  vertex takes over the terminal window: the conversation scrolls above, the input box and status line stay at the bottom, and resizing the window reflows everything to fit.

  Why it matters. A long conversation stays readable and the input is always in the same place.

  How to use it. Scroll up to read back. Resize the window any time.