What are cloud agent cards in CoLateral?

Until October 2026, every agent CoLateral ran was a local command-line tool in a Terminal Card. Cloud agents are different: the work runs on the provider's servers, under the provider's plan, tools and approvals. CoLateral's job is to give you a place for them on the same canvas as your files and your local agents, and to keep what it relays honest about what has and has not happened.

For the local half of the story, see every AI agent CoLateral runs. Local agents are covered in running Claude Code and Codex side by side.

What arrived in the first week of October 2026?

1. October 1, 2026

   Native ChatGPT and Claude cloud agent cards

   Cards for ChatGPT Workspace Agents and for Claude Code routines, the two native subscription cloud agents.

2. October 1, 2026

   Gemini and Jules cloud workflows

   Gemini Deep Research and Jules, added with safe action recovery so a lost response is never silently resent.

3. October 1, 2026

   Full provider apps on the canvas

   The default Agent, Cloud choice became the provider's full app in a Browser Card, with the API workflows kept as an optional second path.

4. October 3, 2026

   Drafts, continuation and action recovery

   Saved cards now keep draft prompts and run references, and a conversation can continue after a card is restored.

5. October 6, 2026

   Multiple app accounts

   More than one account for the same provider app, each on its own card, with a switch-account control.

How do you run ChatGPT or Claude Code from the canvas without an API token?

Choose Agent, then Cloud. By default this opens the full provider app: ChatGPT opens chatgpt.com and Claude Code opens claude.ai/code, each in a private Browser Card. You sign in directly in that card and handle multi-factor prompts and site protections yourself. The provider's own conversation, tools, approvals and account limits apply. No API token or published routine is needed.

The Browser Card still needs the local browser service, and if that service is unavailable the card shows a recovery message rather than implying the provider opened. Profiles belong to the Browser Card and stay separate from your personal Chrome. Restoring a saved card does not submit a task. Cloud providers do not gain access to local canvas tools just because their website is open on the canvas.

The catalogue also includes Claude Chat, Gemini, Grok, Microsoft Copilot, Perplexity, DeepSeek and Jules, and an Another AI website entry that accepts an explicitly entered HTTPS address with no embedded credentials. These open the provider's full app. They are websites in a card, not extra API adapters or local CLI agents.

How do the optional API workflows work?

API workflows have their own controller cards. You connect a provider once through the card's optional setup form, then sending launches a provider-hosted task. Each provider needs its own kind of credential, and they are not interchangeable.

Credentials are stored by the local bridge in an owner-only secrets directory, never in the canvas document, and a token is never returned to the interface after you enter it. The store refuses to fall back to an inherited secret if a stored configuration is damaged. Owner-only storage protects against other ordinary accounts on the machine. It is not encryption and it does not protect against the same user or an administrator.

Why does an accepted cloud task not mean a finished task?

Because the providers' interfaces differ, and CoLateral will not pretend otherwise. Claude's routine endpoint returns a hosted session link without streaming output, and its trigger token has no read access, so the transcript stays in the provider's own interface. Stopping the local relay or deleting a credential does not prove that an already-launched cloud run stopped. Cancellation is offered only where a provider documents a supported way to do it: Gemini research can be cancelled, Jules cannot through this integration.

Failure handling follows the same principle. Local validation and pairing failures happen before submission, keep your draft and say the task was not sent. Once a request has reached the network, an unreadable response stays uncertain and is never automatically resent. The bridge records an operation identifier so repeating the same operation does not issue another provider action, and an unknown outcome is kept for you to review. Jules plan approval always needs your explicit action.

How do cloud agents differ from local agents on the same canvas?

• A local agent is a process on your computer, started through the Local Bridge, and it can read the cards you link to it. A cloud agent runs remotely and does not see your canvas.
• A local agent's prompts and the material it reads go to its model provider. A cloud agent's prompts and execution go to the provider's hosted agent. Neither is local inference.
• Local agents appear in the Command Centre rail and can be managed by the orchestrator. Native cloud conversations stay in their own Browser Cards and are not copied into CoLateral's saved API results.
• Switching a cloud app account does not change local terminal accounts, API workflow configuration or the usage bar. See how the orchestrator manages local agents.

Can you keep more than one cloud account?

Yes. Under Cloud, then Full apps, then Accounts and subscriptions, you can list the AI Browser Cards on the current canvas, search and reopen them, and add an account. Each new account is a separate card with its own browser profile, keyed by project and card, and each card has a Switch account control. Labels such as a plan name are descriptions you type. They are not verified identities, entitlements or usage readings, and sign-in cookies are not exported with a labelled card.

What do you need to bring?

Your own accounts and tokens. CoLateral supplies no model credits, and it does not host the inference. A provider's subscription, API charges and usage limits are separate from the CoLateral licence; see pricing for the licence and the setup answers for installation. Get the desktop app from the download page, start with an invented project, and read the provider's current terms before you connect a paid account.

Why did CoLateral move from a dashboard to a canvas?

Because the dashboard answered the wrong question. A dashboard asks "which tool do you want?" and sends you away to use it. A project is a pile of related things at once: notes, drawings, documents, the tool you are halfway through, a reminder. The previous post in this series ends with a repository that served all of it as one flat static site. On 2026-06-29 that changed on several fronts in a single day.

1. June 29, 2026

   A desktop migration plan

   A planning pass maps the repository and proposes a target layout for a local-first desktop app, with no files moved yet.

2. June 29, 2026

   Shared code moves into packages

   Core modules, shared data, configuration and the AI runtime are extracted into packages with compatibility shims, and AI runtime storage is put behind an injectable persistence adapter.

3. June 29, 2026

   A Tauri v2 shell

   A minimal desktop shell under apps/desktop opens a native window on the existing app.

4. June 29, 2026

   A one-time licence replaces monthly tiers

   The four-tier monthly subscription on the About page is swapped for a single one-time licence.

5. June 29, 2026

   The first Project Canvas

   project-canvas.html is added as a standalone page of movable, resizable cards.

The migration plan states the goal in one sentence, and the rest of the summer follows it.

What was the first Project Canvas?

The commit that introduced it was careful about what it was not. It added "the first infinite-canvas workspace for CoLateral, where existing tools, notes, and rough calcs live as movable, resizable cards in space", and it was additive and non-destructive: it coexisted with the dashboard and changed no existing tool or route. Tool cards embedded the existing tool pages as they were. Persistence was local only, with no AI, agents, cloud or Tauri involved. The first version could spawn 20 tools, move, resize, rename and connect cards with labelled lines, and recover from a corrupted save.

The same day added reference cards for PDFs, images and files, relationships between cards, and a keyboard-first command palette. On 2026-06-30 the canvas got a floating top dock in place of its left sidebar, a free-draw mode, free-drop text boxes, a tool picker, an iOS-style spring transition when a card takes focus, and a landing-page presence. Most importantly, each project became its own isolated canvas that day.

Smaller touches mattered to how it felt. A pixel-art companion called Beam Buddy arrived on 2026-06-30 and got a chat bar that recognised local commands. Notes were rebuilt as a word-processor-style rich text editor. On 2026-07-01 a local PDF could be opened as a card, marked up and exported as an annotated copy without modifying the original. A calendar became a card on 2026-07-02. Each of these made the canvas a place to keep a project, which is a different product from a place to launch a tool.

When did CoLateral add AI agents to the canvas?

On 2026-07-02, in two steps that landed on the same day. The first was Agent Cards: AI workflow cards that read the cards linked to them as context, generate copy-ready prompts, and turn pasted responses into new reviewable cards. In the browser that worked fully by copy and paste, and the design already included a provider registry with placeholders for a desktop Claude Code, a Codex CLI and local models. One rule from that commit has aged well: anything with an invalid review status is forced back to Draft, "so agents and imports can never mark work Approved".

The second step made the placeholder real. Terminal Cards put the user's own authenticated command-line agent live on the canvas, as a real terminal session drawn as a tile. The commit describes the design in a sentence that is still the product's position on AI accounts.

What is the CoLateral Local Bridge?

The Local Bridge is why a browser-style canvas can host a real terminal safely. The original commit lists its guardrails: loopback-only HTTP and a minimal WebSocket server, token pairing with a timing-safe compare, a strict command allowlist with no "run anything" path, and a throwaway workspace for each session. It exports the cards linked to an agent as context files and writes a briefing file that both Claude Code and Codex read natively, so the agent understands the canvas the way it understands a codebase. Deliverables go to an outputs folder and can be imported back as Draft Output Cards.

One more detail shows the philosophy: the agent's initial task was pre-typed into the terminal but not submitted. The person reads it and presses Enter. CoLateral has kept that bias toward a human in the loop in the features that followed, and the agent card on screen today tells you the agent asks before anything risky.

How did the Tauri desktop app come together in July?

The Tauri shell scaffolded on 2026-06-29 was deliberately minimal. During July it became a real host. A fix for Tauri production builds in OneDrive-synced folders landed on 2026-07-15, file drag-and-drop onto the canvas was fixed inside the desktop app on 2026-07-16, and on 2026-07-17 the desktop host started and supervised the Local Bridge itself, generating a per-run token on the loopback address and pairing automatically. That is the change that made a Terminal Card work without anyone running a command or pasting a token.

The quieter work was just as telling. On 2026-07-03 the landing page was redesigned with a live canvas as its background, and on 2026-07-10 a layout pass made cards larger and tool spawns three-pane. A Remotion-based marketing video package was added on 2026-07-02, the start of the project's film tooling. By the end of the month the project had stopped being a collection of pages with a canvas on top and was a canvas with a website beside it. The next post covers that split and the first releases.

What did this era change for people using CoLateral?

• A project became a place with its own saved board, not a menu entry.
• Notes, PDFs, a calendar and tool pages could live next to each other and be connected by arrows.
• An AI agent could run on the same board as the work it was helping with, using an account the person already had.
• Nothing about an agent ran without the person pressing Enter, and everything an agent produced landed as a draft.

The canvas was still an infinite plane at this point, and cards could be any size. That would change on 2026-08-12, when the plane became a filmstrip, and the story is in from tool shelf to agentic workspace. For the screens themselves, see the visual history, for every agent CoLateral now runs, see AI agents in CoLateral, and to try the current app, the download page has it.

What changed in CoLateral between August and October 2026?

More than in any earlier era, and it is easiest to see as five threads that ran at once. The canvas was rebuilt around arrays. A console called the Command Centre became the board's home. The set of agents widened from two to many. The base product was separated from optional add-ons so it could be discipline-neutral. And a store opened for those add-ons. The desktop releases carried all of it: the version number moved from 1.0.25 on 2026-08-26 to 1.0.68 on 2026-09-30. The first releases are in part 3, and the later notes are collected in the 2026 release notes.

How did the Project Canvas become a filmstrip?

On 2026-08-12 the canvas stopped being an infinite plane. The commit that did it said so in its first sentence.

Cards became the same size, snapped into arrays, one array per fixed page of a one-dimensional strip. A page is 2560 by 1600 world units, a 16:10 shape that lines up exactly with the grid the canvas already drew. A card can span several slots, and a card kind can declare a minimum size, so a terminal or a slideshow is never crammed into a ninth of a page. The migration of existing boards was written as a pure function with its own tests, because a bad migration would silently rearrange a real project.

Much was removed. Zoom stopped being a user feature on the same day, because the canvas now travels between arrays. The minimap went because, as the commit explained, a minimap answers where your viewport is inside a large plane, and this was no longer a plane. Its replacement keeps working at scale.

The Tidy button became Arrange, which sorts cards into arrays of however many slots you choose. Folders were retired on 2026-08-13 because grouping is what arrays do now. Arrays could be named after what is on them (2026-08-18), renamed from the band under their tile, and given the shape of the window on a stretched or second screen. The practical result is that a large board is a strip of labelled pages rather than a wide field you have to pan across. The look of it is in the visual history.

What is the Command Centre?

It started on 2026-08-11 as a card that fetched a ranked briefing from a separate local process, and the next day it was reworked so it no longer depended on that process. Three sources now feed it, in order: the person's own connected Google or Microsoft account, read in their browser; the local process, off by default; and failing both, the canvas itself, with to-dos that are due and meetings starting soon. A fresh install can rank a day on its first run.

The design problem was legibility. On 2026-08-22 it was turned into a widget board, and on 2026-08-24 into a console with a single composer, because the earlier board of tiles had a flaw its own documentation names bluntly.

The chief of staff arrived on 2026-08-23. Every agent row stopped saying "idle" and instead said what the agent last did, read from the thread saved on its card. A written summary above the tiles is produced by a model reading every agent's last exchange at once, running through the same local bridge and the same signed-in subscription as everything else, so there is no second backend and no CoLateral key. The commit describes the posture: it is summoned rather than resident. On 2026-08-26 the chief pane was made the orchestrator in full, with one transcript shared by the card and the bar, and a new stop action that ends an agent's turn while keeping its session and history.

How did CoLateral become a discipline-neutral workspace?

By separating what everyone needs from what only some people need. On 2026-08-11 the workspace, which the repository calls the seat, was split from optional add-ons. The base product was made discipline-neutral: a person in any field gets a canvas, agents, documents and the ability to build their own tools, and anything specific to one trade became a separate, optional pack. On 2026-08-22 the README was rewritten around the seat and its expansion packs. The origin of CoLateral as tools the founder built for engineering work is part of the history, but since August the product has not been defined by it.

Naming caught up with that. The site was pointed at colateralai.com on 2026-08-22, replacing a different domain that had not been bought. "Agentic workspace" appears in the site title on 2026-09-23, in the home hero on 2026-09-24, and in the hero description on 2026-09-26. The headline followed the product by weeks, which is the honest order.

How did more AI agents get onto the canvas?

Through a rule that each new agent must fit the same tables as the last one, and a habit of asking who cannot currently use CoLateral. The commit messages from 2026-08-18 are explicit about the reasoning.

Copilot CLI went in that day so a person at such a firm could say yes to CoLateral. Gemini CLI followed with its free Google sign-in, so that, in the commit's words, an engineer with no AI subscription at all can open a Terminal Card and have a working agent. Grok Build joined for people who already hold a SuperGrok or X Premium subscription. Each arrived through the same terminal picker, command bar, voice path and companion rather than as a special case, and a fix the same day stopped every agent except ChatGPT from reporting itself as Claude. On 2026-08-28 CoLateral began launching the Antigravity CLI for Gemini sign-in.

The set kept widening. A Canvas Browser, with scoped control by a connected local agent, arrived on 2026-09-12. Terminal Card agents could run in memory-limited Docker containers when isolation is on from 2026-09-26. Native ChatGPT and Claude cloud agent cards arrived on 2026-10-01, with Gemini and Jules cloud workflows added the same day. Isolated local AI accounts, selectable per terminal, followed on 2026-10-06. Throughout, CoLateral supplies no model credits: you bring your own account. AI agents in CoLateral lists each one and how it got there.

Agents also learned to work on documents: from 2026-08-19 they could write a slideshow, and by 2026-08-26 they could edit spreadsheet, Word and PowerPoint cards.

How did expansion packs and the store come about?

Once the seat was neutral, optional capabilities needed a home. CoLateral Marketing first appeared as the Social Media Pack on 2026-08-25, with a demo recorded on a live canvas, and was renamed in late September. An in-app marketplace and a private creator intake with human review arrived on 2026-09-09, and a payout path for creators of the packs the store sells was added on 2026-08-31. CoLateral Arcade, a games module that is on by default and can be switched off in Settings, was added on 2026-09-26. What is available to add today is on the store and on pricing, and the expansion packs explainer describes the model.

What came next for CoLateral?

The next chapter is being written in the repository now, and the pillar history will keep a record of it. To try the current build, visit the download page.

Where do you choose a model in CoLateral?

There are three places, and each answers a different question. The agent card's model chip decides what a single Terminal Card runs. The orchestrator model setting decides what the bottom bar's chosen CLI runs for typed requests. Voice mode has its own model choice, which is a realtime model or a ChatGPT subscription through Codex. CoLateral itself ships no model. Every list below is a list of models that your own agent and account can run.

How did the model chip arrive?

Before 22 August 2026, which model a Terminal Card ran was pinned in a settings panel and only reached the CLI at launch. Someone watching a card work could not see what it was on, and changing it mid-session meant typing the CLI's own model command and answering its menu, which surfaced in the chat as a blocked question. The chip moved the choice onto the prompt row.

Switching is honest about what the CLI allows. On a running Claude Code session, CoLateral types the CLI's own model command with the name attached, which Claude Code takes without a menu. Codex and Gemini open an interactive picker for that command and the other CLIs have no in-session command, so CoLateral types nothing, the chip says the change applies at relaunch, and it turns amber if the pin and the live session disagree rather than claiming a switch that did not happen.

That honesty was tightened on 14 September 2026. The chip had reported what it asked for, not what the session was on, so a switch the CLI did not take left the chip naming a model that was not running. Claude Code repaints its model name beneath the composer every frame, so CoLateral now reads the running model back from the screen and reconciles the chip against it. A switch that cannot be typed because the agent is waiting on a question is queued and typed when the session is free, instead of being dropped.

How did each release change the picker?

1. August 22, 2026

   The model chip

   The model moved onto the agent card's prompt row, with a live switch for Claude Code and a relaunch note for CLIs that cannot take one.

2. August 23, 2026

   The Claude menu Claude Code actually has

   The picker offered half-names for Opus, Sonnet and Haiku, lacked Fable and used a browser prompt for Other. It became the full-name list Claude Code's own menu shows, with no Other entry.

3. August 26, 2026

   Ask each agent what models it has

   A catalogue now runs a provider's own listing, or for DeepSeek reads the endpoint's list with your key, when you open the picker. It never runs a command that needs a sign-in, and a failure is an empty list rather than an error.

4. August 28, 2026

   An orchestrator model setting

   Settings gained a picker for the model of the CLI that runs the bottom bar, so a session on Opus does not keep answering after you pick Sonnet.

5. September 1, 2026

   Names carry the version

   A picker still saying Fable 5 a release after Fable 5.1 shipped prompted a change: the names now carry the version, and a test reads the menu out of the installed Claude Code and fails when CoLateral's names fall behind. A Claude card now always names a model and starts on Opus, which is what Claude Code's own default resolves to.

6. September 14, 2026

   Grok 4.6

   Grok 4.6 was added to the Grok Build picker. It was named because Grok's own listing named it as what every new session starts on.

7. September 22, 2026

   Pickers read the installed CLIs

   The orchestrator picker said Opus 5 while Claude Code's opus alias already ran Opus 5.5, so the bridge began reading the names from the installed Claude Code. The same day Codex and Gemini model lists came from their installed CLIs, and the card menu was deduplicated so one model shows once.

8. September 29, 2026

   Sonnet 5.5 shows

   The picker began reading Claude Code's native model registry, so Sonnet 5.5 appeared. The change touched five files, two of them tests.

What does each agent's model list show today?

Why does the picker show names the CLI prints?

Because a written-down list goes stale without anything breaking. Claude Code's picker is four aliases that keep working when the model behind one is replaced, so a CoLateral label can fall behind its model while the card launches fine. The comment in the code says it directly: Settings said Opus 5 while the opus alias already launched Opus 5.5. So the card stores the alias, which survives a release, and the visible name is read from the installed CLI.

For most other agents the opposite problem applies. A hardcoded model that an account is not entitled to is a card that will not start, and which models an account has is decided by its plan. So CoLateral asks the machine that knows. The same rule explains why Kiro and Cursor are not read automatically: their listing commands open a sign-in, and a sign-in triggered by opening a dropdown is not something a picker should do.

What should you do when a new model ships?

1. Update the agent's CLI first. CoLateral reads the model names from the CLI you have installed, not from the provider's website.
2. Open the model chip on the agent card, or the orchestrator model picker in Settings. If the CLI lists the model, it should appear. If it is not listed, use Other and type the name your plan allows.
3. Check what is actually running. The chip reads the running model back from Claude Code. On other agents a change applies at relaunch, and an amber chip means the pin and the session disagree.
4. Check the provider's plan limits. The subscription usage bar shows windows where a provider records them, and a bigger model can draw a window down faster.

The same pattern covers the other agents on the canvas; every AI agent CoLateral runs lists them, and running Claude Code and Codex side by side shows two cards with different model chips. The orchestrator's own model setting is covered in the orchestrator and Command Centre. Models run on your own accounts, so check the setup answers for installing a CLI, the pricing page for the CoLateral licence, and the download page for the app.

What is the CoLateral orchestrator?

Before 30 July 2026 the bottom bar was a command box that matched short commands such as dropping a note. The orchestrator turned it into the application's intelligence layer: it sees the canvas, places cards, opens tools, and can start a coding agent, send it a refined instruction, watch the output and report what happened. For a longer account of the agents it manages, see every AI agent CoLateral runs.

How did the bottom bar become an orchestrator?

The first version, committed on 30 July 2026, ran on a realtime speech-to-speech model you pick and pay for with your own API key: GPT Realtime 2.1, GPT Realtime 2.1 Mini or Grok Realtime Voice. Later the same day a second commit moved typed requests onto your own Claude Code or Codex subscription. The reasoning was that the bar is a Terminal Card without the terminal, so typing into it should cost no API key and no CoLateral spend, while voice stays on a realtime model because a CLI cannot stream speech.

Three design choices from that day still hold. The local deterministic parser sees typing first, so dropping a note costs no round trip and no token. A headless CLI cannot call a function, so it drives the canvas with a text protocol, a fenced block with one JSON object per line. And both backends land in the same tool dispatcher, so they cannot drift apart in what they can do.

On 6 August 2026 the bridge began keeping one headless session alive per session key instead of starting a CLI for every action round. Which CLI runs the bar, and since 28 August 2026 which model, is a setting. Voice is separate: Dictate types what you say and sends nothing, and voice mode holds a spoken conversation.

How does the orchestrator manage your agents?

The orchestrator treats Terminal Cards as managed agents. It can open one, read its state, wait for it, give it work, answer a question it asked, interrupt it without ending its session, and close it. Two of those arrived after the first release. On 1 August 2026 it gained the ability to close the agents it opened, and the commit that added it also made it refuse to close tool cards, because a tool holds entered inputs and part-finished work that nobody else can see. Stopping an agent, as distinct from closing it, arrived on 26 August 2026.

Reaching the canvas does not mean bypassing review. Every tool is classified as read-only or destructive, and a destructive one goes through an approval gate. Permissions and confirmation behaviour still depend on the selected agent and action, so read what each prompt shows before you accept it.

What is the Command Centre?

The card arrived on 11 August 2026, shipped in desktop release 1.0.8, and began as a board of tiles fed by a separate local briefing service. By 24 August the card had grown to hold agents, a calendar, an inbox and any panels your own agent had written, and the commit that reshaped it described the result as everything visible and nothing legible. On 24 August it became a rail and a pane.

1. August 11, 2026

   The Command Centre reaches the canvas

   A card that shows what to work on next, shipped in desktop 1.0.8, with the start of a local source that does not depend on the separate briefing service.

2. August 23, 2026

   A chief of staff and honest agent rows

   Each agent row stopped saying idle and began saying what the agent last did, read from the thread saved on its card. A strip above the tiles summarised the board.

3. August 24, 2026

   A console with one composer

   The tile board became a rail and a pane with a single text box whose recipient follows what the rail has selected.

4. August 26, 2026

   The chief of staff is the orchestrator in full

   The chief pane drew the same whole transcript as the bar, and a stop control joined the orchestrator's tools. Desktop 1.0.26 shipped the same day.

5. August 27, 2026

   A pinned home array

   Desktop 1.0.28 made the array holding the Command Centre the board's pinned home page.

Agents lead the rail by whether they have stopped, not alphabetically, because an agent waiting on an answer is the only thing on the card that costs time by being ignored. Beneath each name is what that agent last did, never just a state word. Clicking an agent shows its conversation drawn as its agent card draws it, or a live reading of its terminal.

What does the chief of staff do?

The chief of staff is the first entry on the rail, and it is the orchestrator with a place to stand. It is not a second agent. The bottom bar is the always-on quick line, reachable from anywhere on the canvas, and the Command Centre is the same thread at full size with the briefing above it. A prompt sent from either lands in one history, so a question asked of the bar in the morning is in the chief's conversation that afternoon.

Its written brief is a model reading every agent's last exchange and writing a few sentences, the way a chief of staff would on the way into a meeting. The commit that introduced it on 23 August 2026 set the posture: summoned rather than resident, reading what has been written, and never messaging the agents itself. It ran on the same subscription CLI as the bar, so there is no second backend and no CoLateral key, and it rewrote itself at most every half hour and only when the board had moved.

How do you use them together today?

1. Open the Project Canvas and set which signed-in CLI runs the orchestrator, and optionally its model, in Settings.
2. Type a request into the bottom bar, for example to open an agent on a note and have it draft a summary. The orchestrator opens a Terminal Card, briefs it and reports back.
3. Drop a Command Centre card from the creation dock or the command palette. There is one per canvas, and asking for a second brings the first forward.
4. Select the chief of staff to talk to the orchestrator, or select an agent to type straight into that agent's terminal. The chip at the start of the box names the recipient before you type.

Both depend on agents running on your own accounts, so what they can do is set by those plans and each card's permission settings. See running Claude Code and Codex side by side for the card setup, how model releases change the model picker for the model choice, and pricing for the CoLateral licence, which is separate from any provider account.

Why was it built as one conversation with two doors?

Two sessions against one canvas is the thing the design avoids. An earlier Command Centre pane kept its own smaller history cap, so scrolling up in the card ran out of conversation while the bar still showed it, which read as a lost thread. It now takes its limit from the one store that keeps the transcript, and the card sends through the workspace's own orchestrator rather than building a session of its own. Review each agent's result on its own card: a fluent report is not the finished work.

The bottom bar is the quick line you can reach anywhere, and the Command Centre is where you look to see what to work on next. To start, download CoLateral, try it on an invented project, and read the setup answers if your CLI is not detected.

What is a Terminal Card, and why does it run your own CLI?

A Terminal Card puts a command-line coding agent on the Project Canvas as a card. The commit that introduced it on 2 July 2026 gave the reasoning in one sentence: the engineer's own authenticated CLI, a real terminal session shown as a canvas tile, driven by the user's own subscription, with no API keys and no CoLateral-side AI cost. The design has not changed in that respect.

The Local Bridge is the part that makes this safe enough to ship. It listens on the loopback address only, pairs with the app by token, and will only start commands from an explicit allowlist. There is no "run any command" route. It starts each session in a throwaway folder, writes the linked context cards into that folder as files, and writes a briefing that both Claude Code and Codex read natively, so the agent understands the canvas the way it understands a codebase. The first task you give it was typed into the CLI but not submitted, so you read it and pressed Enter yourself.

How did Codex join Claude Code in CoLateral?

The two CLIs were allowlisted together on 2 July 2026, but a Terminal Card could only be reached from the older workflow card and was pinned to Claude Code at creation. Two changes in the last week of July closed the gap.

1. July 28, 2026

   Terminal Cards become first-class

   A Terminal button on the canvas dock and an Add Agent Terminal command palette entry made a card reachable without a workflow card, and the bridge gained a real Windows pty. A Look panel set the theme, font and layout.

2. July 29, 2026

   A CLI picker for Claude or ChatGPT

   The card's status bar gained a picker. Choosing ChatGPT ran your ChatGPT sign-in through the Codex CLI. Switching stopped the live session, because the process belonged to the old CLI.

3. July 29, 2026

   Codex starts without a prompt

   Codex asks whether to trust a directory on first run in any new folder, and the bridge creates a fresh folder per launch. Launching it with a workspace-write sandbox answered that question while keeping it contained to the session folder.

Two details from that week explain why the design is careful. First, Codex installs through npm as a batch shim on Windows, and Node refuses to start a batch file with arbitrary arguments, so the question goes in on standard input rather than on the command line. Second, a question typed for ChatGPT could have landed in a live Claude session and been answered on the wrong account while looking entirely normal. The card now only hands a question to a live session that runs the same agent as the chosen backend.

How do you run Claude Code and Codex side by side?

The steps below describe the current flow. Control names can differ between releases, so compare them with your installed version, and read the setup answers if a CLI is not detected.

1. Install and sign in to each CLI you want, outside CoLateral. CoLateral does not create provider accounts or supply model credits.
2. Open the Project Canvas and add a Terminal Card from the creation dock or the command palette. Add a second one.
3. On each card, choose the agent: Claude for Claude Code, ChatGPT for Codex. Set the folder, the model chip and the permission chip for that card.
4. Draw an arrow from any note, document or tool you want the agent to read. A linked card is exported into the session folder as context.
5. Press Launch, or type a message at the card. A message sent to a cold card starts the session and is delivered once the CLI has drawn its first screen.

Why does each agent get its own session and account?

Because a shared session would blur whose work and whose bill each answer was. On 18 August 2026 a status line was found reporting every agent but ChatGPT as Claude, because it had been written as a two-way check. That is the worst kind of mistake in a status line, whose job is to say which account is about to be used. The fix was to read names from one table, and the same table now supplies every picker, palette entry, card title and setup guide.

That table is why a third and fourth agent were cheap. Copilot, Gemini and Grok Build arrived on 18 August 2026 as rows in the table plus their own launch details, not as new card types, and Kiro, Cursor and OpenCode followed on 19 August. Every AI agent CoLateral runs lists them all. The cost of the table is that each agent still behaves differently: trust prompts, how a prompt is delivered and how permissions are named all vary, and each was checked against the real CLI rather than assumed.

What does it look like in motion?

The film's captions make the same point as the commit history: the agents run on the CLI plan you already pay for, and that plan's limits are the limits. To see how much of a window is used, the subscription usage bar reads it where the provider records it.

What do you do with two agents once they are running?

Use them for different jobs, and review each result on its own. One agent can draft while the other checks a different file, and because both see the same linked cards you can compare their reading of the same source. You can also ask the bottom bar to open and brief them for you, which is the subject of the orchestrator and the Command Centre. Download CoLateral to try it with an invented project first, and keep any private material out of your first run.

Why is CoLateral a one-time licence?

Three reasons, all of them written down in the repository rather than reconstructed afterwards.

1. The workspace is complete on its own. The comment above the licence ladder in the website's configuration says it directly: "CoLateral is bought once, not rented." A licence buys the workspace, and nothing in it is held back to be sold monthly.
2. The AI is not part of the price. CoLateral supplies no model credits, so there is no ongoing inference bill for a subscription to cover. I explain that decision in why CoLateral uses your own AI account.
3. The one recurring thing is separate and optional. Expansion packs and modules are the only charge that can renew, and they sit on top of a licence you already own. More on that below, and in CoLateral expansion packs explained.

What does one CoLateral licence include?

The pricing page calls it "Everything, in one license". In plain terms that is the Project Canvas with its notes, sheets, documents, to-dos, terminals and tools, agent cards that run on your own provider login, and the ability to describe a tool you need and have it built on your canvas. The pieces that matter for the one-time decision:

• Two computers. One licence activates two of your computers. If both slots are in use you can release an old device and activate the new one.
• Three platforms. Windows, macOS and Linux are all covered by the same key. The download page says which installers are published at any time.
• A key by email. The key arrives when payment goes through, with a Download button. First activation needs the internet, and the app asks you to reconnect at least every 30 days to keep the licence verified. The FAQ adds that your licence is still yours if the connection drops.
• A locked price. The price you pay is locked to your licence. Nothing is charged twice.

For the current price and how to buy, go to pricing. I have left every figure out of this post on purpose, because prices change and that page is the one that stays correct.

How does the CoLateral licence price ladder work?

The price is not fixed, and I would rather say so plainly than let it surprise anyone. It rises in steps as licences are sold: a first group of ten licences, the next fifteen, and then from licence twenty-six onward the settled price. The whole ladder is published on the pricing page, and a rung never rises for a licence that has already been sold.

The reasoning is on that same page, and I cannot improve on it:

The repository records how this is built. The website's configuration notes that the numbers are mirrored from the application's own licence-pricing module, which turns a live "licences sold" counter into the price a buyer is actually charged, and that a static page cannot read that counter. So the site names the rung it is currently advertising, and moves it when a rung sells out.

Did CoLateral always sell a one-time licence?

No. The git history shows me changing my mind, and it is more honest to show that than to present the current model as if it was obvious from day one.

1. June 29, 2026

   A one-time tiered licence

   The commit "Replace pricing with one-time tiered license + live counter" swaps a four-tier monthly subscription for a single licence whose price steps up as licences are claimed, backed by a licences-sold counter.

2. July 3, 2026

   Subscription tiers

   The commit "Replace About page pricing with subscription tiers and founder ladder" replaces that block with a grid of recurring subscription tiers.

3. August 24, 2026

   Back to one-time

   The commit message records that the platform had been a monthly or yearly seat with a separate lifetime tier "bolted on for scarcity", and that it is now a one-time purchase where the scarcity ladder is the price. The one recurring charge left is an expansion pack.

4. September 2, 2026

   Say it plainly

   The commit "Say the live one-time price instead of a rung on sale" records that the home pricing heading "sounded like a moving target", so it now names one-time.

That August commit also caught a bug the change would have caused. The licence issuer treated a "perpetual" licence as meaning one of the retired limited tiers, so once every licence was perpetual it would have granted a pack to every buyer. Pack access became an explicit flag instead. A pricing model touches more code than a pricing page, and that is one more reason I would not want to keep switching.

What is recurring in CoLateral, if the licence is one-time?

Only optional modules. The pricing page answers the question in three sentences: the licence "is paid once and never renews". "An optional module can have its own billing cycle." And: "Cancel CoLateral Marketing and your workspace and projects stay where they are." CoLateral Arcade is the built-in games module, and it starts enabled.

The repository states the product split behind that: the workspace is discipline-neutral and complete, and a pack "is a shortcut past the describing". A pack is prebuilt work for one area, layered on a licence you have already bought, and it can be cancelled without touching the licence. The expansion packs post covers which exist.

What does the CoLateral licence not include?

• AI usage. CoLateral supplies no model credits at any price. Agents run on your own Claude Code or Codex login, or your own Anthropic API key, and your provider bills you. Without one, the canvas and tools still work and the agent panel does not.
• Optional modules. They are separate, and any recurring billing belongs to them rather than the licence.
• Professional judgment. CoLateral is software, not professional services. Agent work stays a draft until you approve it, and responsibility for the final work stays with you.
• A refund after the fact. The FAQ states that purchases are final, and the Refund Policy has the details, including what to do about a duplicate charge.

How do I buy CoLateral?

Start at pricing. After payment the licence key is emailed to you with a Download button for Windows, macOS and Linux, and you enter the key on first run. If you want to see how the product is built before you buy, I wrote about that in building CoLateral in public, and the About page links the livestreams and the Discord.

Why does CoLateral use my own AI account instead of its own credits?

The honest answer is arithmetic. CoLateral is a one-time licence. A single payment cannot fund inference that keeps costing money every time an agent works. On 2026-08-18 the constraint was written into the repository while I weighed a different way of building the agent layer:

There is a second reason that I find just as persuasive. Most people who would use CoLateral already pay for an AI subscription or have a provider login. The pricing page says it plainly: "Agents beside you. Claude Code or Codex on your own login, billed by your provider. CoLateral supplies no model credits." It would be strange to ask you to pay for the same intelligence twice.

Which AI providers does CoLateral work with?

The public pricing page and FAQ name two paths: your own Claude Code or Codex CLI login, or your own Anthropic API key entered in the app. The repository records a wider set of local coding agents that follow the same model. Its account documentation lists separate profiles for Claude Code, Codex, Copilot, Gemini, Grok Build, Cursor, OpenCode and DeepSeek, and the commit history shows several of them arriving as new rows in the same provider tables rather than as special cases.

• On 2026-08-18 a commit titled "Let people run the Grok subscription they already pay for" added Grok Build as a fourth provider.
• The same day, "Let people run the Copilot seat their employer already pays for" added the Copilot CLI as a third. Its message gives the reason: "A lot of working engineers are at firms whose AI policy approves GitHub Copilot and nothing else."
• On 2026-08-19, "Let people run the Cursor subscription they already pay for" added the Cursor terminal agent as a sixth.

The titles repeat one idea on purpose: CoLateral points at the subscription you already pay for. The full list, and how each agent got in, is in AI agents in CoLateral. Check the FAQ and the in-app setup notes for exactly what each connection needs before you rely on it.

How does CoLateral run my agents without handling my login?

A CoLateral agent card does not call a model itself. It starts the provider's own command-line agent on your computer, through a small local service called the Local Bridge, and shows that session on the canvas. The agent signs in the way it always does, with the provider's own prompts. The repository documents the rules the bridge follows: credentials stay on your machine, nothing about a credential or its folder belongs in canvas metadata or exports, and the bridge does not copy credentials out of your default CLI configuration.

Cloud agents work on the same principle. The repository's cloud-agent notes say the bridge is "a secure local relay: credentials remain local, while prompts and execution go to the provider's hosted agent", and that it does not replace cloud execution with "CoLateral-hosted inference".

The bottom-bar assistant works the same way. On 2026-07-30 a commit titled "Run the bottom bar on your own subscription, not an API key" moved it to your own Claude Code or Codex CLI, run headlessly on whatever account is already signed in, "no API key, no CoLateral spend". The one exception it records is voice: a command-line agent cannot stream speech, so the microphone is the only part that wants a key.

Why not build on the Claude Agent SDK instead?

I looked at it seriously, and the repository keeps the answer. An assessment dated 2026-08-18 asked whether Anthropic's Agent SDK could run on an engineer's existing Claude subscription. Technically it can; it wraps the CLI. The commit that closed the question records the reading of Anthropic's documentation that third-party developers may not offer claude.ai login for their products, Agent SDK agents included, unless previously approved.

That left an API key as the SDK's only permitted credential here, which sends the design straight back to the economics above. The same commit records what survived: asking Anthropic for approval, a bring-your-own-key option as a possible third path, and the typed tool surface CoLateral already exposes to an agent running in your own Claude Code. I did not build an SDK backend. I am reporting the repository's reading of the terms, not giving legal advice, and you should read your provider's current terms yourself.

What do I pay for, and to whom?

The price of the licence is on pricing. The price of the AI is between you and your provider, and it depends on the plan, limits and any overage your provider applies.

What happens if I do not have an AI account?

The workspace still works. The pricing page says that without a Claude Code or Codex login or an Anthropic API key, "the canvas and the tools still work and the agent panel does not." The FAQ adds that notes, saved canvas content and other local features do not require an AI account. If you want to try CoLateral before connecting an agent, start with a named project and a Notes card, and bring an agent in when you are ready. The download page has the installers.

Can I use more than one AI account in CoLateral?

Yes. The release notes for version 1.0.71, released on 2026-10-06, describe adding multiple Claude Code accounts with separate sign-ins, and say the same selector supports the other compatible local AI providers. A few behaviours from the repository's account documentation are worth knowing:

• Account names are labels you choose. They are never evidence of an authenticated identity or a subscription entitlement.
• Choosing another account changes the next launch. A running agent keeps the account it started with until it is restarted.
• A removed or unavailable profile fails closed, rather than quietly falling back to your computer's default sign-in.

How do I see how much of my subscription my agents are using?

Every agent on the canvas spends an account that CoLateral does not own, and the first sign that a usage window is gone should not be a coding agent refusing halfway through a task. So CoLateral has a slim usage bar in the bottom-left corner of the Project Canvas. The 1.0.61 release notes record that it "names every limit window for each subscription and says what that account meters".

The rule I care about most in its documentation is a short one:

For Claude Code the bar reads the same windows the CLI shows; for Codex it reads rate limits the provider already wrote to disk. Where a provider records nothing, the bar says "n/a" and says why instead of inventing a number. A made-up percentage on a strip you plan your day around is worse than none.

If you want the story of why I build CoLateral in the open, including the decisions above, read building CoLateral in public. The About page links the livestreams and the community.