Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
Changelog
What changed, for somebody deciding whether to upgrade. Written for the person running OpenBot, not for the person who wrote the commit: a line belongs here when a deployment behaves differently afterwards, and does not when only the code moved.
Newest first. Unreleased is what is on main and not yet tagged.
Unreleased
Before upgrading. Sixteen things change for an existing deployment:
- Bots now share one computer per person instead of each having its own. Migration
0069_isolated_botsaddsagent_profiles.isolated, off for every existing Bot. With the supervisor (laptop, Desktop, Compose), a person's computer is created the first time one of their Bots acts, as<namespace>-computer-person-<id>, and the supervisor stops the old per-Bot containers when it starts, keeping their volumes. A private Bot's logins are copied into its owner's computer once; public Bots, the built-in ones included, sign in again once, because their old logins were shared by everyone who used them. Helmsharedmoves private Bots' profiles the same way. On Helmsandboxnothing is copied, so private Bots sign in again once there too. With the supervisor, a private Bot's files come along the same way, into its folder on its owner's computer; a public Bot's old files stay in its old volume. Old per-Bot volumes are left in place; remove them when you are satisfied. Helm's computer memory defaults rise to a 2Gi request and an 8Gi limit. - A hosted computer's browser is now headed by default. It uses a little more memory than headless
did; set
COMPUTER_BROWSER_MODE=headless(Helm:computers.browserMode: headless) to keep the old behaviour. - Migration
0054_memory_on_intelligenceadds two columns topersonal_memories. On a deployment entitled to Intelligence memory, the memory sweep then copies existing reviewed, switched-on memories into Intelligence, a few people at a time each minute; it is idempotent and safe to interrupt. Memories awaiting review, paused or forgotten stay local until that changes. - With nothing saved under Admin → Automatic Learning and no
CPK_INTELLIGENCE_LEARNING_CONTAINER_ID, the server assigns its Intelligence project'sopenbotcontainer once it exists, andscripts/start.shcreates that container. A saved setting, including off, is never changed;OPENBOT_LEARNING_AUTO_ASSIGN=false(Helm:config.learning.autoAssign: false) prevents it. - Migration
0055_default_opt_outsadds one table,default_opt_outs, where a person's removal of a default memory source or background research is recorded. Memory sources and background research then switch on for each person and Bot that talk (below), so expect background research turns, and their model tokens, four hours after a person first talks to a Bot. Only removals from now on are recorded: a source or research setting somebody deleted before the upgrade left no trace, so it comes back on their next conversation with that Bot (one they turned off and kept stays off).OPENBOT_MEMORY_SOURCE_DEFAULTS=falseandOPENBOT_PROACTIVE_DEFAULTS=false(Helm:config.memory.*) prevent it. - Migration
0056_sign_in_code_stepwidens the check onsign_in_requests.statusto allowcode_required(below). A server and a computer must be upgraded together: an older computer has no/sign-in/code. - Migration
0060_app_access_requestsadds one table,app_access_requests, where a person's request for an administrator to switch on a work app, grant it to a Bot, or connect a Shared app's team account is kept, with who answered it and when. It starts empty and nothing is backfilled. - Migration
0066_recorder_extensionadds six tables for the OpenBot Recorder and each person's own Learning space (below):recorder_connect_codes,recorder_connections,recorder_trajectory_bindings,learning_person_spaces,learning_skill_sharingandlearning_open_skills. Nothing existing changes, and the tables stay empty until somebody connects a browser or changes Settings → Learning. - The CopilotKit runtime moves to 1.79.1. A built-in Bot whose
openai/...model is reached through anOPENAI_BASE_URLthat is not OpenAI or Azure now calls that endpoint's Chat Completions API (/chat/completions) instead of the Responses API. That is what most OpenAI-compatible endpoints serve, so Bots behind one of them now work; a gateway that also serves the Responses API loses Responses-only features, such as reasoning summaries, without an error.COPILOTKIT_OPENAI_API=responseskeeps the Responses API (chatforces Chat Completions); any other value is an error when a built-in Bot runs. Deployments on OpenAI or Azure are unchanged. - Migration
0067_recorder_activityadds two nullable columns torecorder_connections, where each OpenBot Recorder's latest recording activity is kept. Nothing existing changes. - Migration
0061_suggestion_supersededwidens the check onproactive_suggestions.statusto allowsuperseded(below). Open suggestions from before the upgrade stay open until that Bot's next research run replaces them. - Migration
0062_action_policy_labelsadds alabelscolumn toaction_policies, defaulting to empty. Existing boundary rules keep working and show as "Custom rule" until somebody names them. - On Helm's
sharedcomputer and the docker-composeagent-computer, each Bot's files now live incomputers/<Bot id>on the workspace volume (below). Files saved before the upgrade stay at the root of the volume, where no Bot sees them; move them into a Bot's folder to give them back. - With
OPENAI_BASE_URLset to a host that is not OpenAI or Azure,openai/...models now use the Chat Completions API rather than the Responses API (below). SetCOPILOTKIT_OPENAI_API=responsesto keep the old behaviour. - Interfaces a Bot drew before the upgrade (A2UI 0.9 surfaces) no longer draw when a conversation is reopened; the messages around them stay. New ones use A2UI 1.0 (below).
- A computer now closes browsers nobody is using, least recently used first, when its memory
reaches 85% of its limit, and closes a Bot's background tabs after ten minutes untouched (below).
In the all-in-one image that share counts the database and the API server too.
COMPUTER_MEMORY_HIGH_PERCENT=0andCOMPUTER_TAB_IDLE_MS=0(Helm:computers.memoryHighPercentandcomputers.tabIdleMs) keep the old behaviour.
An unreconciled app authorization always reaches the audit trail
An app authorization whose vendor answer cannot be reconciled is now settled and audited together. When an attempt settles as unreconciled, its status and its audit row are written in one transaction, so the trail always says what happened to it, without the authorization's id, consent link or vendor account. If the audit row cannot be written, nothing changes and the attempt stays pending, rather than settling with no record.
Refunds now go to the person
The built-in safety rules hand paying, purchasing or moving money to you, but a refund action
(such as SHOPIFY_CREATE_REFUND) passed straight through: "refund" was not one of the words the
rule looked for. It is now, so issuing a refund is handed to you like any other movement of money.
A computer run on a laptop can stay off the local network
A managed computer listens on every network interface, which a container needs. Run straight on a
laptop with bun run dev, that left its token-protected API reachable from the local network.
COMPUTER_BIND now chooses the address it listens on: set COMPUTER_BIND=127.0.0.1 to keep it to
the machine itself. Unset, nothing changes, and a computer driving a native Chrome (OpenBot
Desktop's) still always listens on loopback.
A computer closes browsers nobody is using when its memory runs high
A computer runs one browser for each Bot that is browsing, and the only limits were a count and half an hour untouched. Neither looked at memory, so a few heavy pages could take a container past its memory limit well under the count, and the kernel then killed processes without regard to which Bot was busy. On Kubernetes it kills everything in the container at once, so every Bot's browser closed together and nothing could reach the computer until it came back. A computer now reads its own memory the way the kubelet does (the working set, which leaves out the file cache the kernel can drop), before it starts a browser and once a minute. At or above 85% of its limit it closes browsers one at a time, least recently used first, until it is under 75%, so the next launch does not cross the line again straight away. Launches that arrive together share one pass rather than closing a browser each. A Bot whose browser was closed starts again where it left off on its next step, still signed in, because its profile is on disk.
Only a browser nobody is using is closed. Never closed for memory: the browser being started, the most recently used one, any browser used in the last minute (a Bot between two steps asks for nothing while its model works out the next), a person's own browser, cloud or native, whose Recorder session would end, and the browser of a Bot whose wheel a person holds or has been asked to take. When every browser is in use, none is closed.
This is a check, not a guarantee. Memory is read before each launch and once a minute, so a page
that grows between two checks can still run the container out of memory. A container with no memory
limit is measured against the machine's memory, and a computer outside a container, such as OpenBot
Desktop's, closes nothing for memory. In the all-in-one image the database and the API server run in
the same container as the browsers, and the share counts them too. That is deliberate: the kernel's
out-of-memory kill counts everything in the container and can take the database down, and closing a
browser nobody is using first is how the database is protected. Each close is logged as
computer-browser-closed-for-memory with the working set and the limit in bytes.
COMPUTER_MEMORY_HIGH_PERCENT (Helm: computers.memoryHighPercent) sets the share where closing
starts, and 0 switches it off.
The tabs a Bot leaves behind are closed too. A Bot always works in its newest page, so an older tab,
such as the page a sign-in popup was opened from or a link a site opened in a new tab, is one it
cannot go back to, and it held memory for as long as the browser stayed up. A background tab that
nothing has used, navigated or brought to the front for ten minutes is now closed. The page the Bot
is on is never closed, and neither is any tab of a person's own browser or of a Bot whose wheel a
person holds. COMPUTER_TAB_IDLE_MS (Helm: computers.tabIdleMs) sets the time, and 0 keeps them.
Through Helm, computers.browserIdleMs and computers.maxBrowsers now reach the computer as
written. An hour (browserIdleMs: 3600000) used to render as 3.6e+06, which the computer ignored
for its default of thirty minutes, and browserIdleMs: 0 (keep browsers open) was dropped. All four
of these settings now also reach the computers computers.mode: sandbox makes, which had none of
them.
A conversation opens at the bottom and stays still while a Bot writes
Opening a conversation shows its newest messages at once, already at the bottom, instead of loading and then gliding down; a long one draws older messages as somebody scrolls up to them, without moving what they are reading. Charts, tables, cards and decisions a Bot draws grow in place while they stream, and no longer flash "not available" before they appear. A reply is revealed at a steady pace, and the view follows it until the person scrolls up or selects some of it, and picks it up again when they come back to the end or press the arrow. A rail beside a conversation has a mark per turn: hovering one previews what was asked and answered, and choosing it goes there. Nothing changes for a deployment.
Generated interfaces use A2UI 1.0
With generative UI on, a Bot builds an interface from CopilotKit's standard catalog on A2UI 1.0 instead of the 18 A2UI 0.9 basic components. That's 65 components for layout, text, inputs, tables, charts, media and composites such as entity cards and image grids, including the A2UI 1.0 basic components under their A2UI names. They take OpenBot's colours, radii and font, in light and dark.
Four are left out. Map needs a map library OpenBot does not ship. Favicon, LinkCard and Citation load site icons from Google's favicon service, which would send every linked domain to Google.
None of these is listed in the components gallery, and an admin can't turn one off for a Bot. The
gallery components a Bot is granted are unchanged. OPENBOT_GENERATIVE_UI=false still switches it
all off, on the server as well as in the browser.
CopilotKit 1.83
OpenBot now runs on CopilotKit 1.83.0 (@copilotkit/runtime and react-core, from 1.77.0) and
AG-UI 1.0.2 (@ag-ui/core and @ag-ui/client, from 1.0.1). A managed Intelligence project needs
nothing changed. A deployment whose OPENAI_BASE_URL points at an OpenAI-compatible gateway rather
than OpenAI or Azure now reaches openai/... models through Chat Completions; a gateway that only
speaks the Responses API needs COPILOTKIT_OPENAI_API=responses.
Pick a skin: OpenDuet, OpenDots or OpenMuse
Settings → Preferences → Skin changes how OpenBot looks for you, and nothing about what it does.
Three skins draw the open-source templates' looks over OpenBot's own features: OpenDuet (one
phone-width column with Chat and Tasks), OpenDots (a rail, a sidebar of Bots with their avatars, and
the Bot's computer beside the chat) and OpenMuse (one Bot at the centre, with Chat, Activity, Ideas,
Goals and Apps). Every skin keeps your deployment's name from brand.yaml, OpenBot's own mark and
each Bot's own avatar; only the look changes. The choice is saved on your account, so it follows
you to every device, and changes nothing for anybody else. The templates' own features that
OpenBot has no server for, such as OpenDots' Spaces, OpenDuet's morning brief and OpenMuse's mail and
calendar, are not part of the skins.
Each person's Bots share one computer, and a Bot can have its own
Every Bot used to get a computer of its own, which on a laptop or Desktop meant a container per Bot
running all the time, and meant everyone who used a public Bot shared its logins. Now all the Bots a
person uses run on that person's one computer, each with its own browser profile and folder, so a
login belongs to the person and the Bot, never to everyone who uses it. Tick Isolated when you
make a Bot, or in its Setup, to give it a computer of its own that keeps its logins; everyone who
uses that Bot shares that computer. Administrators decide who may: Admin → Enterprise → Isolated
Bots, on for everyone by default, and can be turned off for everyone or allowed for chosen roles and
groups. When it is turned off for somebody, their isolated Bots run on their own computer from the
next run, and the Bot's Setup says why. A deployment with one shared computer (Helm shared, or no
supervisor) cannot give a Bot its own, and the checkbox says so.
As is the industry standard for an always-on agent's computer, the Bots on a person's computer are not kept from each other: a command any of them runs, a public Bot somebody else made included, can reach anything on that computer. Each Bot still keeps its own browser profile there, which is stricter than the standard, where a person's Bots share their sign-ins too. The admin Computers screen says this, and a Bot that must be kept apart is made Isolated.
An isolated Bot's one computer is shared by everybody who uses it, so its Setup says, before it is made public and while it is, that anything signed in to there is theirs too. Only the Bot's owner's switch decides whether it may be isolated: an administrator ticking Isolated on somebody else's Bot is refused when that owner lacks the switch, rather than saving a tick the Bot never ran with.
A person's computer runs a browser for each of their Bots in use, so Helm's computer now requests
2Gi of memory with an 8Gi limit (was 1Gi and 4Gi); computers.resources in values.yaml says how to
size it. Removing a person or deleting an isolated Bot leaves its computer until an administrator
resets it from Admin → Computers, which signs every Bot on it out of everything.
The audit log reads like a log
Admin → Audit fills the window and runs the table across the whole pane, with the title, the views and the search held in place while only the rows scroll. Each row shows the full date and time and a mark for what happened, with blocked rows tinted red and actions that did not happen tinted amber. The newest come first, and a press on When turns the order round. A search box and Outcome, Bot and Started by buttons narrow the events already loaded, and the count says how many of them match. A row about a Bot (a message routed to it, say) now names it under Bot.
The desktop setup page does not freeze when it loads during an install
If the setup page loaded again while the desktop app downloaded local software, the window showed a spinning cursor until the download finished. Its checks for a running OpenBot and for the last failure now wait in the background, so the window keeps answering.
Each Bot on a shared computer has its own files
A computer that serves many Bots kept one folder of files for all of them, so a note one Bot saved
was a file every other Bot could list and read. Each Bot now gets its own folder, and its commands
start there. Logins were already kept apart. This is on for Helm's shared computer and the
docker-compose agent-computer, and COMPUTER_SEPARATE_WORKSPACES=on turns it on for the
all-in-one image. A command can still read another Bot's folder, so a deployment that needs people
kept apart should give each Bot a computer of its own (computers.mode: sandbox).
Every chart says where its figures came from
A chart a Bot draws now ends with a line naming what its figures were read from and when they are from, such as "Sources: World Bank World Development Indicators · As of 2025". Figures a Bot charted from its own knowledge, without looking them up, are marked "From the Bot's own knowledge. Not checked against a source." Bots are told to look up figures that change over time before charting them. In Slack and Teams the same line follows the chart in the reply. Charts already in a conversation are drawn as before, with no such line.
A Bot searches with its search tool, never its browser
Asked to search for something, a Bot could drive its browser to Google or another search engine instead of using the search tool it held. With a search tool it now searches with that, and keeps the browser for signing in, clicking through a site, filling in a form or opening a page the person named. Without one it answers from what it knows, says it has not checked, and shows a card for a search app (Parallel Search, Exa Search or Firecrawl) that the person can ask an administrator for.
A computer that is starting says so, instead of showing a problem
Opening the Computer panel while a Bot's computer was asleep or starting showed "Can't show the screen right now", and an action during a cold start was marked "didn't work". The panel now says the computer is starting, or is off until the Bot next uses it, and shows a problem only when it can't be reached or has gone two and a half minutes without a picture; a live screen being reconnected shows a small "Reconnecting…" badge. An action turned away by a cold start reads "not done yet" and the Bot is told to try again. Looking at the panel no longer wakes a sleeping computer, a Bot says in one sentence what it is about to do before its first computer action, and a hosted computer's cold start answers within 45 seconds, under a load balancer's usual 60-second idle timeout. A Docker computer still booting its browser reads as starting once the supervisor is upgraded too; an older supervisor works as before.
A conversation shows who it is waiting on
When a Bot asks another Bot, the end of the conversation now shows that Bot's avatar and "Asking
Risk Analyst…" until the answer comes back; a routine firing into it reads "Market Scout is running a
routine…". A Bot whose address this deployment will not dial is reported at once, not after five
minutes of retries. The sidebar keeps the conversation lit while it waits, and both survive a
reload. In a shared conversation only the person whose Bot asked sees whom it asked; the others see
only that it is busy. Migration 0063_work_items_open_thread adds one partial index to work_items.
A Bot's owner can give it their own apps
The owner of a Bot can now let it use an app they connect for themselves, without an administrator:
from the app card ("Let Research Bot use your Gmail?"), under Your apps on the Bot's page, or on the
New Bot sheet, which offers their connected apps. Calls under such a grant always use the asking
person's own account, even on a published Team Bot, and an owner can take back only what they gave.
By default this covers apps each person connects for themselves and Routines; an administrator
decides per app on its page, and can switch it off for people with the "Give apps to their own Bots"
capability. Migration 0063_owner_app_grants adds two nullable columns, mcp_servers.owner_grants
and plugin_grants.granted_as.
Where an administrator lets owners give a Shared app, an owner's grant works straight away: it lets
the people who can use the Bot (just the owner, or a Team Bot's audience) use the team account, with
no separate approval. Writes still ask first. Taking the app back, or the administrator switching the
app back to admins only, withdraws that. Migration 0064_owner_shared_audience adds the nullable
shared_use_approvals.approved_as.
An app card carries the task on once the app is ready
When a Bot stopped because it needed an app, and the person then connected it in another tab or an administrator turned it on for the Bot, the card said "Ask again". It now sends "Gmail is ready now. Please carry on." for the person, once, and the Bot picks the task back up; a card opened after the change offers Continue instead. An administrator looking at the card gets the fix itself, "Turn on and give it to Sales" or "Give it to Sales", which grants the app's read-only actions with the same checks and trail as approving a request, or a link to the app's page where one press can't do it.
Screens share one spacing, row and empty-state design
Every configuration screen now takes its spacing from the page frame: 32px under the title, 48px between sections, rows at least 56px tall with dividers inset to the text. Rows draw their icon as a glyph on a small tile, and a section with nothing in it says so with an icon, a title and, where there is one, the button that adds the first thing. The root font size is the browser's 16px again, with text kept on its 15px scale, so Tailwind sizes are their documented values.
Adding a credential and a boundary rule are screens of their own
Add credential opens a page with a back button instead of a dialog. Boundaries is now a list of named rules ("Bots may never…"); adding one starts from a template or a blank rule and can be tested against recent activity before it applies, and each rule opens to what it has stopped lately.
A Bot's page is shorter
Its In progress, Scheduled and Completed lists move to their own Activity page. The Bot's page keeps what is running or scheduled, three at most, with a dot on anything under way, and shows its newest three suggested next steps with the rest behind "Show more".
Suggested next steps no longer pile up
Each research run replaces the open suggestions from the one before, and one with the same title as a suggestion that is already open, or was dismissed in the last 30 days, is not suggested again. The research is asked to suggest nothing when nothing needs doing, and not to name the Bot's tools.
Pin or delete a conversation from its Bot panel
The gear panel in a conversation ends with Pin and Delete for that conversation.
The @ menu shows each Bot's avatar, at the caret
On the home screen the @ menu opened away from the text, partly off the window; it now opens at the caret. It is wider and shows each Bot's avatar beside its name.
Outside content that looks marked as untrusted is marked anyway
A connector's answer was passed to the model without the untrusted-data notice when its text already started and ended like one. That text could carry a notice in its own words, or close the tag and continue with instructions outside it. Content is now left as it is only when it is exactly what OpenBot itself wrapped; anything else is wrapped.
Filling in a form is no longer mistaken for paying
The built-in safety rules (paying or moving money, credentials, security settings) read the words a Bot typed as well as where it typed them, so a Bot entering a CRM note about a customer's purchase orders, or a press release's source such as Business Wire, was stopped with "Paying, purchasing or moving money is always done by the person" and the step handed back to you. Typing is now judged by the field, the page and the button: a card number field, a checkout page or a new password field still goes to you, whatever is typed. A news wire (business, news or press wire) on a link or button no longer counts as wiring money; wiring money still does.
A page visit an approval rule covers now asks you
With an approval rule that asks before a Bot opens, reads or scrolls a page, the Bot was told the action "was not started from a conversation that can ask you", did nothing, and said it could not get an approval in this chat. The visit now waits on the approval card in the conversation, like a click or a command does: Allow once opens the page and the Bot carries on, Deny tells the Bot it was declined. Page visits no rule asks about still go straight to the computer.
A Bot's browser step is no longer refused while it is being saved
Before your browser runs a click or a typed entry for a Bot, the server checks it against the copy saved in the conversation. That copy is saved a moment behind, a piece at a time, and a check that read it half saved refused the step with "That unanswered tool call is not saved in this conversation" or "Supply a valid request", so a form the Bot was filling in could stop partway or ask for your approval twice. The check now waits, as it already did for a step not saved at all, until the step is saved whole.
A Bot can choose from a dropdown
A Bot filling in a form in its browser could not set a dropdown (a native <select>, such as a CRM's
Industry or Stage). Typing into one waited until it timed out and was reported as a field that had
gone from the page, so the Bot took a fresh snapshot and tried the same thing again. Typing into a
dropdown now chooses the option it names, by the option's label or its value, and the page sees the
same change a person's choice makes. Text that names no option is refused with a message saying so.
A page snapshot now lists each dropdown's options and the one it shows, so the Bot can see what it
may choose and what is already chosen.
A Bot carries on after a browser step fails
When a click, typed entry or key press the Bot made in its browser failed, the Bot's turn ended on the spot: the step showed "Didn't work" and the Bot said nothing more. The failure now reaches the Bot like any other result, so it can take a fresh snapshot, try another way, or tell you what stopped it. A refused step reads as a refusal the Bot can explain.
The computer image is about a fifth smaller to download
The openbot-agent-computer image carried two copies of Chromium: the full browser it runs, and
Playwright's separate headless shell, which it never starts. Every launch names a Chromium channel,
and Playwright runs the full browser for a named channel even with COMPUTER_BROWSER_MODE=headless.
The image now installs only the full browser and drops the package cache left from installing it.
The download falls from 537 MB to about 423 MB on arm64 and from 520 MB to about 411 MB on amd64.
Unpacked, the image is about 375 MB smaller on arm64 and 296 MB smaller on amd64. The all-in-one openbot image installs the same browser the same way and shrinks by about
as much. The browser and its behaviour are unchanged. On a desktop install the computer is the
largest image, so a first install and each upgrade download less.
A Bot can send, draft and reply in Gmail
OpenBot left out every Composio action that takes a file, because a Bot has no way to supply one. That also left out actions where the file is optional, such as an email's attachment, so Gmail's send, draft, reply and update-draft actions never appeared and a Bot could read mail but not send it. These actions are now offered without the optional file, and a call that includes one anyway is refused with a message saying to try again without it. An action that cannot run without a file, such as uploading one to Google Drive, is still left out. For an app that is already on, press Refresh tools on its page in Admin to list the new actions, then grant them to a Bot as usual.
Connect works for an app Composio already holds your account for
Pressing Connect on a Composio app, from a conversation's Connect card or from Connections, could end in a refusal saying Composio already held a connected account for the app and that disconnecting it would clear the way. The app showed as not connected, so there was nothing to disconnect. This happened when Composio held the account and OpenBot had no record of it: on a fresh or upgraded install, or on a second local install signing in as the same person with the same Composio key. Connect now asks Composio again, records the account it holds, and shows the app as connected, the same way opening the app's page already did. A Shared app's team account is still recorded only by an admin. If Composio then reports no account after all, Connect says nothing was connected and asks you to press it again. It no longer tells you to disconnect anything.
A Bot with an app or web research can use its browser in a conversation again
A Bot that held any app or research tool, such as Parallel Search, could not open a page, click or type in a conversation: every browser and computer step came back as unavailable, and the Bot fetched the page some other way instead. Its browser now works beside those tools, as it does for a Bot that holds none. Routines and other unattended turns are unchanged.
An app a Bot could not use asks to be connected once
When a Bot reached for an app the person had not connected, such as Airtable, the conversation drew the Connect card twice, and still did after a reload. The built-in LangGraph Bot now names the message its tool calls belong to the way the conversation store does, so a conversation no longer keeps a second copy of every tool call, and a conversation that already has one draws each call once.
An app's steps are named for the app, never for the service behind it
A conversation named a Composio app's work after the broker and the vendor's own prefix: "Used
Composio Airtable", then "Airtable list bases". It now says "Used Airtable", and each step reads as
the action, "List bases", with the app beside it. An Arcade app is named the same way, as the app
rather than arcade-Gmail.
An app a Bot cannot use yet asks once per turn
When a Bot's call to an unconnected app was refused, the Bot often also asked to show that app's card, and the conversation drew the same Connect card twice. Each app's card is now drawn once per turn; asking again in a new message can draw it again.
The Computer panel shows the Bot's screen when it opens
Opening the Computer panel beside a conversation could leave it on "Waiting for the Bot's screen…" while the Bot browsed, because the panel slid in from off-screen and the screen counted as out of view for as long as it stayed open. The panel now starts showing the screen once it has opened.
Plainer words, and one word for each thing
OpenBot now says Bot everywhere a person reads it, where screens used to mix Bot, agent, coworker
and assistant; "agent" is kept only for an outside program you connect. It says admin rather
than administrator, conversation rather than channel, and OpenBot rather than "this
deployment" on pages anybody can open. Headings, descriptions, empty states, errors and the
messages the server shows are shorter and say what happened and what to do next, across the home
page, a Bot's pages, Capabilities, Connections, Settings, conversations and Admin. Admin keeps the
exact setting names an admin needs, such as COMPOSIO_API_KEY. Text written for the model, such
as tool descriptions and instructions, is unchanged.
Every settings screen is the same, slightly wider column
Settings, Admin, Connections, Capabilities and each Bot's pages share one column width, now 720px instead of 630px, so no screen is wider than another and a row has room for its label beside its control. Sentences keep their comfortable reading width inside it. The audit log stays wider, because it is a table.
Capabilities and Connections sit beside Bots in the sidebar
The sidebar's Skills entry becomes two, below Bots: Capabilities (/capabilities), with Skills
(/capabilities/skills) and Memory (/capabilities/memory) as tabs under its title, Memory leaving
Settings; and Connections (/connections), the apps your Bots use as you, which leaves Settings
too. On the home page, Explore agents shows each Bot as a white card with its avatar on top, the same
card as elsewhere. The old
addresses — /skills, /settings/connected-accounts with any account beneath it, and
/settings/memory — redirect to the new ones, keeping ?connected=, ?linked= and a skill being
written or edited, so a consent begun before upgrading still lands on its page. OAuth, GitHub linking
and the Slack link confirmation now send people to /connections.
Connections is one searchable list. Apps you connect, apps on your organisation's account (marked "Team account") and your GitHub and Slack links are rows of the same kind, with those already in use first, and each opens its own page. GitHub's page holds your link, the repositories whose events can start a responsibility (formerly "GitHub events"), and a way to a Composio GitHub app where one is enabled, so GitHub is listed once; linking GitHub now comes back to that page. The reset for what you let shared Bots use moves to Settings → Approvals, as Shared Bots.
Each app on a Bot says whether you can use it, and you can ask an administrator for the rest
A Bot's page now says, for every work app the Bot holds, what that app is for the person looking:
ready, not connected yet, needing reconnecting, waiting on your organisation's shared account or on
an administrator's approval of who the Bot reaches, not switched on or not finished setting up, or not
given to this Bot. On somebody else's Team Bot it says whose account the app runs on: the owner's,
which only the owner can reconnect, or your own, which the Bot asks to use the first time. Each comes with the one thing you can do about it —
Connect or Reconnect your own account, or Request access where only an administrator can help — and
apps are named by their own name ("Gmail", not "Composio Gmail"). In a conversation, a Bot that needs
an app it cannot use now puts the same card in front of you instead of a sentence: an account you have
not connected, a Shared app with no team account, an account the vendor no longer holds, and — through
a new show_app_access tool every Bot holds — an app that is switched off or not granted to it. The
card reads the app's current state when it is drawn, so it never offers a step already taken.
Administrators see waiting requests at the top of Plugins, a count on each app's row, and a Requests
section on the app's own page, where Approve switches the app on and grants the Bot the app's
read-only actions in one press (or says what has to be done first; other actions are chosen on the
Bot's page for the app) and Dismiss closes the request. Requests name who asked; nobody's connection
status is shown to administrators. A person may have 20 requests waiting at once.
A connection the vendor turns out to have lost now reads as lost everywhere once a call finds out: a Composio account the vendor no longer holds is removed so it can be connected again, and a Google Drive or Notion connection whose refresh token the vendor refuses is marked withdrawn, with Reconnect on the card instead of a tool error. A Memory source that fails for the same reasons says so in words rather than showing the card's marker.
On a deployment with no COMPOSIO_API_KEY, Settings → Connected accounts no longer lists Composio
apps, which nobody could connect there. An app's own page, reached from an older link, says it is not
available yet and that an administrator has to finish setting it up, instead of naming the setting.
The administrator's page for the app still names COMPOSIO_API_KEY.
A new desktop install of v0.2.0 gets past Install again
A desktop app built from main stopped every new install at "Installing OpenBot" with
shared/package.json: No such file or directory. It had started reading shared, toolkit and
extension as packages, which v0.2.0 does not have: there shared is plain source and there is no
toolkit or extension. It now reads them only when the release includes them.
A built-in Bot behind an OpenAI proxy answers again
A built-in Bot behind a gateway or proxy in front of OpenAI (an OPENAI_BASE_URL that is not OpenAI or
Azure) answers again on gpt-5.6-terra and on every other model that takes tools only through the
Responses API (gpt-5.6 and later, the -pro models, gpt-5.3-codex, also under a gateway's openai/
name). OpenBot now sets COPILOTKIT_OPENAI_API=responses for those at boot, where CopilotKit 1.79.1 had
sent them to Chat Completions and every turn failed with "Function tools with reasoning_effort are not
supported". Every other model still uses Chat Completions there, and a value you set yourself still wins.
Teach a Bot by doing the task in your own browser: the OpenBot Recorder
The OpenBot Recorder is a Chrome and Edge extension. A person names the task, does it in their own browser, and the Recorder sends what they did, step by step (each click, entry, choice, submit, Enter and page change, with what an agent needs to find that element again, and the one request a step sent when it saved something), masked in the browser first, straight to Intelligence as a trajectory in that person's own Learning space; the page's own traffic is never recorded, except the agent's AG-UI events (below). Every Bot they use then gets the Skills learned there, beside the Bot's own. OpenBot connects the browser and hands out each capture pass; it receives nothing that is recorded.
- The agent's side too. On a page whose agent speaks AG-UI (over SSE or the Intelligence
WebSocket, OpenBot's own chat included), the Recorder also sends the agent's side, in exactly the
shape the CopilotKit SDK emits so Intelligence cannot tell the two apart:
agent.run,agent.message(the person's own messages too),tool.callandthread.linked, a click inside a chat message with its Thread and message, andagent.eventfor what those leave out (a tool call's arguments and result, state, reasoning, errors), never one row per streamed token. CopilotKit's suggestion runs are left out, as its own capture leaves them out. - Clicks and typing come from CopilotKit main's own capture code, carried as a Bun patch over
@copilotkit/learning0.0.1 (patches/, which the images and OpenBot Desktop copy) until main is published. - Settings → Browsers connects the Recorder in this browser and lists every browser connected as you, each with a Disconnect. OpenBot Desktop can connect the Recorder on its own computer too.
- Only a connected browser gets a capture pass. The runtime's
trajectory/<id>/connectroute answers only the Recorder's own bearer, and binds the trajectory to that person; no Bot is picked or named. A signed-in session alone gets no pass, and the Recorder's bearer cannot run a Bot or read a conversation. - One Learning space per person. Every recording joins the person's own Intelligence Learning
container,
user-and 32 hex digits derived from their OpenBot user id. OpenBot makes it when the browser connects (and again on a capture pass if it is still missing) with the same credential that makes theopenbotcontainer: a service token on a CopilotKit local evaluation install, or a CopilotKit CLI login against managed Intelligence. Intelligence's runtime key cannot make one. With neither, a missing space cannot be made, and the Recorder's popup says Learning will not see the recording; the recording still goes to Intelligence. - Every Bot a person uses draws on their space. A run gets the Bot's own learned Skills, then
the person's own, then any another person opened (below). On a name clash the Bot's own wins,
then the person's own; two people's opened Skills with one name are both kept, each named
<their space>/<name>. A person's space that is missing or unreachable never fails a run: it goes on with the Skills it has. Admin → Automatic Learning off, or a Bot excluded there, still means no learned Skills at all. - Settings → Learning chooses who else's Bots use a person's Skills: only their own (the default), every Bot in the deployment, or the Skills they open one by one, and only Skills in their own space can be opened. Opening Skills to others needs Admin → Enterprise controls → Skill sharing, off by default: while it is off nobody can open their Skills, runs offer nobody another person's, and each person's choice is kept for when it is turned on. Runs read what is open from memory, refreshed at once on the replica that saved a change and within 30 seconds on the others.
- What the Recorder collects is said before the first Connect (Settings → Browsers, the Recorder's setup page, the Browser page and its Record form): your steps, what each step saves (the request and its answer), the conversation with an AG-UI agent on the page (your own messages too) and your narration, masked in your browser first.
- Narration is off until you choose it, asked before your first recording and remembered, and it is transcribed on your own computer only (Chrome's on-device speech recognition, with the language downloaded once on your click); where on-device recognition is not available, narration stays off and the page says why.
- Every recorded tab shows that it is being recorded, from its first step (a page cannot hide the mark: it comes back at once if removed or hidden), with one click to leave that site out of recordings; a left-out site records nothing, and the Recorder's options list the sites left out. A page you have only looked at is held while you stay on its site, and sent when you act there, move to another tab or stop, so leaving a site out at any point in a visit sends nothing of it.
- A Recorder's connection ends whenever your sign-in ends (signing out, signing out everywhere, an admin removing you or requiring SSO, your organization ending its session), or after it goes unused for as long as an OpenBot sign-in lasts; signing out does not finish, and says so, if they cannot be ended; a recording kept for a person who never connects again is deleted unsent after 7 days. A page on your own computer is trusted to connect without a click only at OpenBot Desktop's own address, as its native host confirms it, and connecting to another OpenBot or as another person always asks you first, saying which connection it replaces.
- Intelligence must allow trajectories: the
trajectorieslicence feature,FF_LEARNING_TRAJECTORIES=true, a realtime gateway that can ask Intelligence whether an organization may capture, and anINTELLIGENCE_GATEWAY_WS_URLthat people's browsers can reach. OPENBOT_RECORDER_EXTRA_EXTENSION_IDSlists other extension ids to trust besides the Recorder's own, for a fork or a build signed with another key. Each must be 32 letters from a to p, comma separated; a value that is not stops the server at boot.- Connecting, disconnecting and refusals are audited as
recorder.connected,recorder.revoked,recorder.connect_refused,recorder.bearer_refusedandrecorder.trajectory_refused; changing Settings → Learning aslearning.sharing_changed,learning.skill_openedandlearning.skill_closed.
When OpenBot is open in Chrome or Edge, the Browser button uses that browser
With the OpenBot Recorder in that browser, one click on Browser opens Record and Stop right in OpenBot, and the red dot follows the recording at once. If the Recorder is not connected yet, the same click connects it (OpenBot Desktop and your organization's own OpenBot, when its address is set by policy, need no Connect click; any other site still asks you to confirm). If it is not installed, the click opens its store page in a new tab. Only the OpenBot the Recorder is connected to can start, stop or see its recordings; any other website is told it is not connected. Settings, Browsers shows Connected straight away when no Connect click is needed. OpenBot Desktop's own window, Safari and Firefox are unchanged.
Your own everyday Chrome or Edge, with the Recorder in it
On OpenBot Desktop the Browser button now works with your own everyday Chrome or Edge: your profile, extensions, password manager and logins, not a separate copy.
- Once the OpenBot Recorder is published on the Chrome Web Store and Edge Add-ons, OpenBot Desktop registers it with your Chrome and Edge, and the browser installs it from the store and asks you once to turn it on (on a Mac the next time you restart the browser, on Windows while it runs, on Linux in Edge only). Before it is there, the Browser button opens the Recorder's store page in your Chrome (or Edge) so you can add it at once. Until the Recorder is published, the Browser button opens the OpenBot browser as before. Uninstalling Desktop on Windows takes the registration back out.
- The Recorder connects through OpenBot Desktop as it installs, with nothing to click. "Connect with OpenBot Desktop" in the Recorder's popup also connects at once; connecting from a web page still asks you to confirm. Once it is connected, the Browser button brings that browser to the front.
- The red dot follows a recording in any of your browsers, your everyday one included, on Desktop and hosted: the Recorder tells OpenBot when it starts and stops recording, and every 30 seconds while it records, and the dot goes out 90 seconds after a browser stops reporting.
- The Recorder says what it collects first on its setup page (above its request for your microphone) and on its Record form, before anything is recorded: every step in every tab you use until you stop, what is on those pages, your clicks and typing (secrets masked in your browser first), what each step saves and what you say, all going straight from your browser to your organization's own Intelligence, with a pass from your organization's OpenBot, which is told that you are recording, the task's name, when it started and how many steps it holds; when you record in a browser shown inside OpenBot, your narration passes through it to the Recorder without being stored.
- Migration
0067_recorder_activityadds two nullable columns torecorder_connections(each Recorder's latest activity). Nothing existing changes.
A recording follows every tab you use
While a recording runs, the OpenBot Recorder now records in every tab you use: any tab you switch to or open, in any window, in the OpenBot browser and in your everyday Chrome. Before, it recorded only the tab you started in and tabs opened from it, so steps in a tab you switched to were lost. Tabs you do not visit during a recording are never recorded, and nothing on the browser's own pages (a new tab, settings) or the Recorder's own is. A tab that reloaded as you switched to it no longer loses the saves it sends.
Record a task in a Bot's own browser, with nothing to install
A Bot's screen, opened larger from a conversation, is now a browser a person can work in: tabs, an address bar, back, forward and reload sit above the page. Take control and the bar is yours (typing an address, switching, opening and closing tabs, all from the keyboard too); while the Bot has control it shows where the Bot is, read only. The OpenBot Recorder is already in every Bot's browser, idle until someone records, so recording a task needs no extension and no Connect step.
- Record replaces "Teach a browser workflow". Name the task, press Record, do it, press Stop. The panel shows the name, the time and the step count, asks about narration before your first recording (the same choice as the Browser page), and after Stop says what was saved to your Learning space. The recording lands in Intelligence exactly as the Recorder sends from any browser, in your own Learning space, so every Bot you use learns from it, this one included.
- Only you are recorded, never the Bot. Record works only while you hold control, and handing it back (or the Bot's request ending) stops the recording, with its last steps sent before the Recorder disconnects; the Bot acts again only once the recording has ended. Taking control now records who took it, so on a shared Bot only that person can use the bar or record, someone else's recording shows only that one is running, and nobody else sees its name, its step count or its microphone.
- Record runs on your own computer, never the one everyone shares. Where every person's Bots run
on one computer (Helm's shared mode, or
AGENT_COMPUTER_URLwith no supervisor), Record is refused in every Bot's browser and the panel says why: your Recorder connection would sit in the Bot's profile, where another person's Bot could read it. The bar still works. The computer refuses it too. With a supervisor (laptop, Desktop) or a Sandbox, a Bot's browser is on your own computer, beside only your own Bots, or on an isolated Bot's computer of its own, and Record works there. Your hand-back ends only your own recording: another person recording in the same Bot's browser on their own computer is never touched. - One connection per recording. Record mints a Recorder connection for the person who pressed it and Stop revokes it; Settings, Browsers lists it as "'s browser" while it lives, and says "recording now" for any browser that is recording.
- While a recording runs in a Bot's browser, that Bot's network policy also lets the Recorder reach OpenBot and the Intelligence gateway, on their own ports only; the Bot's own policy returns when it ends.
- Removed: the old "Teach a browser workflow" panel and everything behind it (its routes under
/api/demonstrations, its instant skill draft, "Save and use with this Bot" and "Run on a schedule"). Skills already saved from it stay, as ordinary skills; its recordings stay in the database, unread. - When you take control yourself, the line under the screen no longer repeats your own request back as if you had said it.
- What you type while you hold control stays yours. After you hand back, the Bot reads a field you filled as "filled in by the person", never its value, in its page snapshot, its page text and its screenshots; a field you only tabbed through keeps the Bot's own value.
- A Bot's request for help shows in the conversation, with its reason and Take control, and folds into one line once answered. After you hand back, the Bot is told what you did and carries on, saying what it does next; if it still stops without a word, the card says so and offers Carry on.
- Clear browser data. One button beside reload, in a Bot's browser and in your own, asks "Clear this
browser?" and wipes it: cookies, saved passwords, history, site storage and the screenshots kept of its
pages. It starts fresh, signed out of everything; OpenBot's own Passwords stay. A Bot's browser can be
cleared only by the person holding its control. Audited as
computer.browser_cleared. - Leaving a conversation while you hold a Bot's control no longer leaves it blank: the Bot's reply after you hand back shows when you return, with no "A browser task is paused" notice.
Your own browser, opened from OpenBot, with the Recorder already in it
Wherever OpenBot can run a browser for you, the sidebar has a Browser button below Connections. It opens your own browser with the OpenBot Recorder already in it and connected as you: no install and no Connect step. On OpenBot Desktop one click opens your browser window, or brings it to the front, and you stay where you are in OpenBot; record with the Recorder's button in that window's toolbar. On hosted OpenBot the click takes you to the browser in the page. While a recording runs, the Browser button shows a red dot; hover it for the recording's name and how long it has run. Name a task and press Record; the page shows the recording's name, how long it has run and how many actions it holds, and after Stop it says what was saved to your Learning space (for example "7 actions and 1 narrated phrase"), or that nothing was recorded, and says the same after a reload. Nothing a Bot does is recorded. When your browser cannot open because of how OpenBot is set up, OpenBot tells you to ask an admin (on single-user OpenBot, such as OpenBot Desktop, to quit and reopen OpenBot), the message stays until you close it, and the reason is in the server's and the computer's logs.
- On OpenBot Desktop it is your installed Google Chrome, or Microsoft Edge where Chrome is missing, in a separate OpenBot profile, as its own window; opening it again brings that window to the front. OpenBot starts it itself rather than through Playwright, so tabs behind the one in front behave as background tabs, and OpenBot follows the tab you are on. It is an everyday browser: install your password manager from the Chrome Web Store (a password manager's link to its desktop app works, such as 1Password's), or sign in to Chrome and sync brings your extensions, bookmarks and passwords; saved passwords use the system keychain. Once you turn narration on, the Recorder hears your microphone itself, and the page shows whether it is listening, muted or cannot hear. Desktop runs this browser as a fourth process beside the server, app and worker, only where Chrome or Edge is installed. Installation copies the Recorder, prebuilt, out of the release's computer image into your OpenBot folder, existing installations download their OpenBot files once more after updating, and Stop and Quit let the browser close cleanly first. Chrome's extensions page lists the Recorder as an extension it cannot verify, because it is not installed from the Chrome Web Store.
- On hosted OpenBot the browser is the computer's Chromium, shown in the page with tabs, an address bar, back, forward and reload, and you click and type in it straight away. Only the Recorder is allowed in it. It runs only on a computer of its own (each person's own, as the supervisor and the sandbox give one): where Bots share one computer, which can run commands, the Browser button is hidden and the Browser page says why. While you record with narration on, the page transcribes it with your own browser's on-device speech recognition (Firefox has none, and the page says so; the narration switch reads off whenever it cannot hear you), and each phrase is placed before the steps you took while saying it. It reaches the open web, and OpenBot and the Intelligence gateway on their own ports, never anything else inside the deployment.
- Only you can see or use your browser, admins included. It appears in Settings → Browsers as your OpenBot browser and can be disconnected there, which signs out the Recorder in it at once (a recording in progress stops and is kept, and goes to Intelligence when you next record). Each open replaces its previous connection, and Record after a Disconnect connects it again first.
- A person's hosted browser closes after going idle as a Bot's does, and the computer's browser cap closes the least recently used first; OpenBot Desktop's own window is never closed for being idle.
- On Linux, OpenBot Desktop also finds Chrome and Edge on the
PATH(Flatpak builds cannot hold the Recorder and are not used), and the Browser page says why when there is none. On Windows, Stop and Quit ask the browser to close before ending it. Uninstalling on Windows, and removing the Linux package, deletes the OpenBot browser's profile and the Recorder's files. OPENBOT_RECORDER_DIRon a computer is the built Recorder it puts in a person's browser; the computer image sets it, and without it the computer still serves Bots and refuses to open a person's browser, saying why.OPENBOT_BROWSER_URLon the server runs people's browsers on a separate computer (OpenBot Desktop sets it). The local Chrome helper (scripts/start-local-chrome-computer.ts) now also starts when only Edge is installed.- A computer's network rules can allow a site by name on given ports only (
portson a domain rule). - Each browser on a shared computer follows its own network policy. Browsers there now identify themselves to the computer's network filter, so a Bot allowed to reach a service is no longer refused because another browser on that computer is not, and no browser borrows another's allowances.
- A hosted person's browser says who it is as a hosted Bot's does (no
HeadlessChrome), but never carries the deployment's Web Bot Auth signature: a person browsing is not the deployment's Bot. - A person's browser always runs the Recorder that came with its OpenBot, even in a profile that ran an earlier one, and keeps it pinned to the toolbar once.
- A Recorder that is slow to answer is refused instead of taking down the computer and every browser on it. Typing on a live screen reaches the page in the order typed.
- Opening the Browser page twice in quick succession (reloading it while your browser is still opening, for one) opens your browser once, connected; before, both opens could be refused, most often the first after the Recorder was updated. When a browser cannot be opened, the server's and the computer's logs say why and at which step.
- Google loads in Bots' browsers again. Behind the computer's network filter, Google's pages never finished loading (Chromium restarts the request for client hints and the restart was lost); the computer now launches every filtered browser with that restart switched off.
- When a page does not open, OpenBot names the site and says it did not load or was refused, instead of showing a browser error, the address bar keeps the address that failed, and a slow page says it is slow rather than that the browser could not be reached.
- A package can no longer give a Bot an id shaped like
person-and 32 hex digits. - The Recorder times a narrated phrase from its first word when Chrome reuses a result slot; it was stamped up to seconds early.
The desktop window answers while software is installing
Clicking or focusing the desktop window while it downloaded local software showed a spinning cursor until the download finished. The window now comes forward at once and keeps the setup screen.
A reinstall no longer picks up the previous installation's Bot files and sign-ins
A desktop installation set up again after its folder was deleted reused whatever the previous one left in the container engine: Bot workspace files, and each Bot's browser profile with its website sign-ins, under the same Bot ids. Only the database was checked. Start now finds every volume and stopped container the previous installation left and offers Start fresh, which deletes exactly those and then starts; nothing is reused without asking. To keep the data, restore the previous folder instead. A container from it that is still running stops the deletion until it is stopped. An installation with its saved key keeps its data as before.
A new desktop install starts its server again
A desktop install of v0.2.0 stopped at start with server stopped straight away (exit status: 1) and
Cannot find module '../../../agent-computer/src/egress'. The server imports its egress rules from
agent-computer, and the desktop app did not copy that folder when it laid out the deployment. It
does now, and a test fails if the deployment's code imports anything the desktop app does not copy.
An install laid out by an earlier app is asked to finish installing when it starts; installing
downloads the same release again with the missing folder. Settings and data are kept.
A new Bot is made from a sheet that asks where it runs first
New Bot opens a sheet instead of the four-screen wizard. It asks where the Bot will run, with Run it here chosen; a framework you run asks for its address next, and Continue checks from the server that something answers there before going on. The name, title, instructions and who can see it come last. A Bot given only a name gets a title and instructions the server accepts: for one that runs here, the instructions are a short prompt naming it. The frameworks list Claude Agent SDK, Google ADK, Google Antigravity and LangGraph first; AG2, Agno and Langroid now show their marks, and every mark sits on a light tile in dark mode.
A run of tool calls folds into one line
Consecutive tool calls a Bot makes without drawing anything now collapse into one line ("Used 5 tools") that opens to show each, as connector calls already did. Calls that draw an interface, and calls waiting on the person, still stand on their own.
Onboarding says which pictures are pictures, and tells a local install more
The illustrations in onboarding sit in a muted frame and can no longer be clicked, tabbed into or
read out as controls. On a single-user install, three more slides follow: that its data stays on
the machine, which agents it can bring, and how to deploy it for an organization.
/api/capabilities gains localEvaluation, true in single-user mode.
An HTML-only email reaches its trigger as the sender wrote it
An email trigger reads an HTML-only mail by stripping its tags, and the character references stayed:
the Bot read AT&T, we’re and Q3 numbers. Numeric references, &, <,
>, ", ' and are now decoded, once, so &lt; reads as <.
An email in another charset reaches its trigger as the sender wrote it
A base64 or quoted-printable email part was always read as UTF-8, whatever charset its Content-Type
named, so an iso-8859-1 mail reached the Bot with every accented letter turned into �. Each part
is now decoded in the charset it names, and a charset the runtime does not know still reads as UTF-8.
The Bot's screen opens only when there is something to watch
Asking a Bot a question it answered in words could still open its computer beside the conversation, on a still screen, for an action that never happened.
- A call that never reaches the screen no longer opens it. Reading, writing or listing a file, and running a command, happen on the computer rather than on its display. Only work that happens on the screen opens it.
- A refused action takes its screen back. The screen is announced before the action so a page can be watched while it loads; an action a policy, a capability switch or a network rule refuses never touches the browser, so the screen it opened closes again. A refusal does not close a screen some earlier action in the same run legitimately opened, and an action that was permitted and failed keeps its screen, because the page may have moved.
- A Bot is no longer given computer tools this deployment would refuse. Admin → Controls already
decided whether anybody may use a Bot's browser (
Cloud browser use), its files and shell (Cloud computer use) and the network (Cloud network access), and the boundary enforced all three — but the Bot was still offered the tools, so it reached for one, was refused, and spent the turn saying so. The tools a switch turns off are now withheld from the Bot in the first place.
A repeated minute in a routine's schedule is described once
A schedule like 0,30,0 9 * * * fires at 09:00 and 09:30, but the routines page and the model were
told "Every day at 09:00, 09:00 and 09:30". Repeated minutes are now said once, as repeated weekdays
already were.
An app you have not connected is offered where you are reading
A Bot asked to use an app whose account the person had not connected answered with the name of a screen somewhere else: "Connect it in Settings and ask again." The conversation now carries the thing itself — a card naming the app, with a Connect button.
- Pressing Connect opens the vendor's consent in a new tab, so the conversation is not replaced by a page load and the question is still there afterwards. The card watches for the account to appear and says so only once the server lists it, never merely because somebody came back.
- It covers an account that was never connected, one disconnected while a call was in flight, and access that was withdrawn. An app shared across the deployment still says to ask an administrator, since the person reading cannot connect it.
No-sign-in startup rejects addresses without a host
With OPENBOT_SINGLE_USER=true, an address such as example.com:3010 in OPENBOT_PUBLIC_URL,
OPENBOT_APP_URL or TRUSTED_ORIGINS now refuses startup. It previously counted as a private
network address and only warned, even though the missing URL scheme left its host unidentified.
A reply's tool calls fold into one line
A Bot that searched, read two pages and checked Drive before answering drew four lines above its answer. Adjacent connector calls and browser steps now fold into one line that says what was done, such as "Searched the web and read 2 pages", with an icon for each kind of step. It names the step in progress while the Bot works, and counts issues when a step was blocked or failed. Opened, it lists each step with its query, page or connector, and each step opens to what it was given and what came back. A single connector call keeps its own line, and approvals, connection requests and anything the app draws itself stay outside the fold.
Public-web research works with Exa and Firecrawl, not only Parallel
Four new catalogue entries give a Bot public-web search and page reading without its browser: Exa Search (free, rate-limited), Exa Search (API key), Firecrawl (free) and Firecrawl (API key). They sit beside the two Parallel entries, and nothing is granted to any Bot until an administrator does it. See docs/web-research.md.
- The research guidance follows whichever provider a Bot holds. It used to switch on only for Parallel's two tools. Now a Bot holding any provider's search and fetch tools is told how to use them, and a Bot holding more than one uses the one the person asks for.
- A Bot holding a research provider searches without being asked when an answer depends on facts that change, such as current figures, rankings or recent events, and stops after a search or two. Before, every Bot was told not to go looking, so one holding a search tool still answered from memory. A Bot with only its browser now says it can open pages but cannot search.
- A conversation doesn't say which provider searched. Research calls show as "Search the web" and "Read web pages" rather than "Web search exa", and the Bot doesn't name the provider unless asked. The Bot's access page still shows which provider it holds.
- The shipped
research-public-webskill declares roles, not Parallel. Its tools are now@research/searchand@research/fetch, which match the search and fetch tools of every research provider the Bot was granted. A skill written by a person can declare the same roles, and the Skills page offers them under "Public-web research". A role grants nothing. - Exa and Firecrawl list their reads. Every other tool they advertise counts as a write, so a Firecrawl monitor deletion or an Exa agent run goes through the same policy as any write.
- An API key can go in the vendor's own header. Exa reads
x-api-key; the deployment key for that entry is sent there. The admin page now says the key is "Sent with every call to this vendor" rather than calling it a bearer token.
Bot turns hold their conversation more carefully
Routines, responsibilities, background research, wake-ups, group turns and Bot-to-Bot handoffs keep a lock on the conversation while they run and renew it as they go.
- A failed renewal no longer stops the turn. Before, any failed renewal stopped a routine or responsibility turn, including a network blip. A stopped turn is retried from the start, so a Bot that had already sent an email could send it again. Now a turn stops when Intelligence says the conversation belongs to another run (409), or when renewals have failed for so long that the lock (120 seconds) would lapse before the next one, whatever the failures were. It stops while the lock is still its own. A shorter blip rides through.
- A handoff that loses its lock now stops. Before, a handoff ignored every failed renewal and kept writing, even into a person's own channel after they started typing there. Now it stops, gives the conversation back and is retried a minute later.
- A paused Bot's handoff no longer locks the conversation. A handoff now checks that the Bot is not paused, and that "Use Bots" and the model allowlist allow it, before taking the lock. Before, every retry took the lock briefly and could refuse the person's own message.
- Routine turns ask for a 120-second lock. This is the lifetime Intelligence already applies, so nothing changes on today's platform.
A sign-in's verification code is asked for after the password
The private sign-in form used to ask for a username, a password and "a verification code, if the
site asks for one" all at once, so a person had to guess whether a code was coming and type one
before the site had sent it. Now the form asks only for the username and password. If the site,
once it has the password, shows a one-time-code field, the request waits in a new code_required
state and the form asks for the code the site just sent, on its own. A wrong code keeps asking; a
code nobody enters expires with the request, and the person can still take over the browser or
cancel. The Bot is told only how it ended, never the code, and a saved login still never stores one.
The step is audited as computer.sign_in_code_requested, and a failed code as
computer.sign_in_failed with step: "code".
A licence token from a store reaches the server
The Helm chart passed COPILOTKIT_LICENSE_TOKEN to the server only when secrets.licenseToken was
written as a literal. A token synced through externalSecrets, which the chart's own EKS example
does, reached the Secret and never the pod, so a self-hosted deployment ran unlicensed with nothing
saying why. It is now passed whenever externalSecrets.data names license-token, and as an optional
reference with secrets.existingSecret, where the chart cannot see the Secret's keys. The chart's
CI check now also fails a render in which a store syncs a key that nothing reads.
OpenBot says at boot when Intelligence will refuse memory
A self-hosted Intelligence needs its own licence. Without one it answers every runtime entitlement
read with RUNTIME_ENTITLEMENTS_SELF_HOSTED_MISCONFIGURED and refuses memory, while conversations
carry on and nothing in OpenBot's log says why. The server now asks once at start-up and logs
intelligence-entitlement-not-ready with the code and where the licence goes, and
intelligence-entitlement-unreadable when Intelligence cannot be asked. Start-up does not wait for
the answer.
The server says at boot when its key cannot call the configured model
A key without access to the tenant package's default_model passed every start-up check and failed at
the first message, as "The model … does not exist or you do not have access to it", in front of
whoever sent it. The server now asks the provider once at start-up and logs model-unavailable with
the model and the fix, or model-credential-rejected for a refused key. It asks only OpenAI and
Anthropic themselves, not an endpoint set by OPENAI_BASE_URL or ANTHROPIC_BASE_URL, says nothing
while no key is configured, and never delays start-up.
The Helm chart pins by digest, mounts a tenant package, and takes a Composio key
Three things a deployment on Kubernetes did by hand now have values of their own:
image.digestdeploys exactly the image a release'scontainer-images.jsonnames, asrepository:tag@digest. It refuses anything that is notsha256:and 64 hex characters.config.extraVolumesandconfig.extraVolumeMountsmount volumes on the server and on the routines and computer-culler CronJobs, the pods that load the configuration. A tenant package from a ConfigMap no longer needs a custom image.secrets.composioApiKey, orcomposio-api-keynamed inexternalSecrets.data, reaches the server asCOMPOSIO_API_KEY. Only the server receives it, not the CronJobs.
With none of them set, every target renders exactly as before.
Fewer "Verify you are human" pages
Sites behind Cloudflare challenged a Bot's browser on sight, and opening one could restart the computer and leave the person a blank page to solve. Now:
- The computer no longer restarts on such a page, and a help request reopens the page the Bot was on, so the person taking control always gets the check to solve. That handoff is the designed fallback for a check a Bot cannot pass.
- A hosted computer runs headed Chromium on its own virtual display, behind the same live screen.
Headless Chromium is what bot checks catch first. A computer still run headless no longer calls
itself
HeadlessChrome. - Web Bot Auth, off unless switched on: with
WEB_BOT_AUTH=on(Helm:config.webBotAuth: "on") and an https public URL, every request a Bot's browser sends is signed and the key is published at/.well-known/http-message-signatures-directory. Register the deployment once with Cloudflare (Bot Submission Form, Request Signature) for sites that allow signed agents to let Bots through. See docs/configuration.md. Every site a Bot visits sees the deployment's URL. - A residential or ISP proxy is a first-class setting:
EGRESS_PROXY_DEFAULT, or on Helmcomputers.egressProxywith the URL in a Secret. Off by default; turning it on makes Bots' traffic look like a person's home connection, which is the operator's choice to make. - Bun 1.4.3 throughout, which fixes the connection crash behind the restarts.
Memory sources and background research are on by default
A fresh deployment used to remember only what a person told a Bot: connected-app memory sources and background research each waited for somebody to set them up, one Bot at a time. Now, when a person talks to one of their Bots in a conversation with that Bot alone, OpenBot switches on background research by that Bot (read-only as before, every four hours, first run one interval later). And from any turn a Bot takes for a person, each app the person connected in their own account, that the Bot can read, becomes a memory source for that Bot, except on a Team Bot somebody else published, where the person's own accounts need their consent. Sources read as the person, their facts reach that Bot only, and imported facts wait for the person's review before they go to Intelligence, exactly as a source made by hand. Shared apps and apps that need no account are not added; a person still adds those by hand.
Turning either off keeps it off, and removing one is remembered: OpenBot never switches it back on,
and resetting the Bot keeps both. Nothing already saved changes. Set OPENBOT_MEMORY_SOURCE_DEFAULTS=false or
OPENBOT_PROACTIVE_DEFAULTS=false (Helm: config.memory.sourceDefaults / researchDefaults) to stop
new defaults for the whole deployment.
Automatic Learning creates its container where OpenBot holds a credential that can
The runtime key cannot create Learning containers, so a deployment without the openbot container
collected nothing until somebody ran a helper. Now:
bun scripts/setup-learning.ts(andscripts/start.shon every start) creates it with a CopilotKit CLI login even when no project is selected in the checkout, choosing the runtime key's project.INTELLIGENCE_SERVICE_TOKENwithINTELLIGENCE_PROJECT_IDlets the server create it by itself, on a CopilotKit local evaluation install (the only kind where Intelligence accepts a service token for Learning).- The Helm chart runs a setup Job when
config.learning.setupnames a CLI-login Secret or a service token Secret. - Admin → Automatic Learning has a "Create the openbot container" button when the deployment holds one of those, and otherwise, like the server log, says exactly what to run.
Automatic Learning assigns its container without a trip to Admin
Learning was on by default but collected nothing until somebody assigned a container. Now, when
nothing is saved under Admin → Automatic Learning and CPK_INTELLIGENCE_LEARNING_CONTAINER_ID is
not set, the server assigns its Intelligence project's openbot container as the default as soon as
that container exists, records it in the audit log, and the Admin page says so. A saved setting,
including off, is never changed. The runtime key cannot create a container, so
bun scripts/setup-learning.ts now creates openbot in an existing key's project instead of
refusing, and scripts/start.sh runs that check on every start without a browser or prompt. Set
OPENBOT_LEARNING_AUTO_ASSIGN=false (Helm: config.learning.autoAssign: false) to keep the old
behaviour.
Memory lives in CopilotKit Intelligence
A deployment entitled to Intelligence memory now keeps its people's memories there: Intelligence holds the content and ranks recall, and memories another app on the same project formed for a person appear in their Memory page and reach their Bots. OpenBot still records each memory's provenance, review state and which Bot or source it came from, and applies those rules to everything Intelligence returns, so a Bot-formed memory still reaches only the Bot that formed it. Without Intelligence memory nothing changes: OpenBot's own tables remain the store.
0.2.0
Before upgrading. Two things change for an existing deployment:
- Migration
0052_shared_brokered_accountscopies every Composio connection into a newbrokered_connectionstable and leavescomposio_connectionsin place, unwritten. Rolling back to 0.1.2 works, but accounts connected after the upgrade are invisible to it. - A handoff now records what started the run it came from. Older remote Bots' signed runs carry no such record for up to ten minutes after the upgrade, and calls they make to a Shared app in that window are refused.
The desktop asks before every command that can edit a folder
When a Bot runs a command in a folder shared from the desktop app, the person sees a prompt that can offer "Always allow in this folder". That choice now covers commands that only read the folder. A command that can change or delete files in it shows the prompt every time, without the "Always allow" option. Folders already set to "Always allow" work as before for read-only commands.
One Bots list, and one page per Bot
Agents, Team Bots and Bots were three lists of the same Bots. /bots is now the only one — pinned,
yours, shared with you, and the ones you hid — with New Bot at the top. A Bot's page holds
everything about it: its routines, its skills and what it may reach, who it is shared with, and its
name, role and connection. Where updates reach you and your answers to shared Bots moved to
Settings. /agents and /team-bots still work and open the new places. A Team Bot an administrator
assigns to a group is pinned at the top of its members' Bots list instead of sitting in their
sidebar.
The sidebar no longer lists each Bot that needs you. A badge on Bots counts the questions, approvals and stalled hand-offs waiting across all of them, and Bots lists those Bots first, under Needs you. Browser notifications when a Bot starts needing you are unchanged.
The sidebar is now Bots and Skills. Each Bot's page holds what that Bot is waiting on you for, its
suggested next steps, its responsibilities, where it reaches you, its memory sources and background
research, and its approval rules. /approvals, /memory, /reachability and /responsibilities
still work and open the new places. Messages from Bots, Slack and Teams that named those pages now
point at the Bot's page.
A group conversation is started like any other: put two or more Bots in the To: field of a new
conversation, in the order they should answer. The separate group button and /group/new screen
are gone; /group/new opens the new-conversation screen.
Settings now also holds whether your Bots ask before acting, rules for every Bot, your memories, your devices and recent deliveries, and GitHub event sources. Team approval settings and shared account requests moved to Admin → Approvals.
People can link their Slack and GitHub accounts
Settings → Connected accounts gains a Linked accounts section with one card per account a person can
link. Slack links through a one-time code sent to the OpenTag app in a direct message; a code posted
in a channel is cancelled. GitHub links through a GitHub App's user sign-in, set with
GITHUB_APP_CLIENT_ID and GITHUB_APP_CLIENT_SECRET (both or neither); the server refuses to start
with them and no public URL. Nothing reads the links yet: they are what GitHub alerts and reviews will
build on. Migration 0053_identity_links only adds tables.
A credential written as the word after a flag is redacted
docker login -p secret, sshpass -p secret and redis-cli -a secret were recorded with the
password in clear: the rules recognised a flag whose name says what it carries, and mysql's attached
-psecret, but not a credential passed as the word after the flag. redis-cli -ahunter2 was worse —
the attached form reads as a flag called -asecret, so the rule for a flag named after a secret
redacted the word after it and left the password. A URL with no user, redis://:secret@host, was
missed the same way, and so were curl's proxy credentials in --proxy-user where -u and --user
were covered. All of them are now redacted, in the command kept for Action Recording and in the copy
exported to a telemetry collector. A password separated from -p by a space is left alone: mysql
asks for it at the prompt and the word after the flag is the database name. Each of these rules ends where its
command does, so the port in sshpass -p secret ssh -p 2222, or in a docker run -p 8080:80 on the
line after a docker login, is left alone.
An app's account can belong to the team
An administrator can make a Composio app Shared: one account, connected once, that every Bot granted the app acts as. Who may use it through each Bot is approved per Bot — owner only, named people and groups, or everyone, and separately whether email, Slack or webhook input may — and checked on every call. Requests to widen it wait in the Approvals inbox. Writes through a Shared app ask the person first.
A new deployment starts with two coworkers, not twelve
The example package loaded every coworker in examples/fintech/agents/, so a fresh deployment opened
with General Assistant, Knowledge and ten more at once. The ten now live in examples/fintech/catalog/,
which is not loaded, and a new deployment starts with General Assistant and Knowledge. Risk Analyst
and the picked harness still register when their endpoints are configured. To keep any of the ten,
copy its file from catalog/ into agents/.
A deployment that already registered them keeps them. A coworker dropped from the package is not
retired on the next boot: its row stays, still listed and still refused by delete as protected,
because only a remote coworker with a blank endpoint is retired automatically. To remove the ten
from such a deployment, set deleted_at on their agent_profiles rows after upgrading (see
configuration.md).
0.1.2
CopilotKit 1.77 and AG-UI 1.0
OpenBot now runs on CopilotKit 1.77.0 (@copilotkit/runtime, react-core and a2ui-renderer,
from 1.73.1), which carries the Intelligence client, and on AG-UI 1.0 (@ag-ui/core and
@ag-ui/client 1.0.1, from 0.0.59). A managed Intelligence project needs nothing changed; it is the
client in the server that moved. Among what comes with it: thread naming falls back to the first
message, the realtime connection keeps its place across a repeated checkpoint, an interrupt resume
gets a run id of its own, and generated A2UI controls no longer submit the page's own forms.
Bots served from their own endpoint keep working as they are. AG-UI 1.0 still accepts the earlier
event shapes, so agent-bot, agent-langgraph and the Python Bots were not changed.
A tool result's error field is gone from the TOOL_CALL_RESULT event, because AG-UI 1.0 does not
define one. The refusal is still in the result's text and on the tool message, which is where a
Bot's next turn reads it.
0.1.1
A password given to
curlas-uuser:password,--user=user:passwordor-u "user:pass word"is now redacted in a Bot's recorded shell command. Only-u user:passwordwith a space and no quotes was recognised, so the other spellings kept the password in the command that was stored or exported.A password, token or API key sent as a JSON field in a shell command is now redacted before the command is kept or exported.
curl -d '{"password":"x"}'was recorded with the secret in clear, because onlyNAME=valueand--name valueforms were recognised and a quoted JSON key was neither. The key is still shown, so the command reads the same.A Bot's browser is now refused names under
.localhost, such ashttp://admin.localhost:5432, the same as barelocalhost. The whole.localhostzone is loopback and Chromium resolves it without DNS, but only the exact namelocalhostwas on the refused list, so a deployment that had not opted into private hosts could still be pointed at its own services this way.OPENBOT_SINGLE_USERis now refused with a public name that starts with127., such ashttps://127.example.comorhttps://127.0.0.1.nip.io. The check for a loopback address matched any host beginning127., so a public address like that read as this machine and the no-sign-in administrator was allowed on it. Only a full 127.x.x.x address counts as loopback now.A cancellation the native host never collected is now dropped instead of being reported as pending forever. Every timed-out, stopped or revoked host operation queues a cancel for the desktop worker, and only that worker ever removed it: a worker that stopped polling left the entry in memory for the life of the process, so the Host access panel showed an operation that could never finish. A desktop that reconnects within the operation timeout is still told to stop.
A Bot's shell now honours a Stop that landed before the command was spawned, not only one that arrives afterwards. A person who pressed Stop in the window between the request reaching the computer and the command starting got no answer until that command finished on its own.
A file download refused because the computer's response carried no usable byte length now releases the connection before reporting the refusal. The unread body could be as large as the whole download budget, so a computer reached through a proxy that re-chunks left a transfer running and a connection checked out of the pool on every attempt.
A conversation title cut at 60 characters no longer ends in half an emoji.
slicecounts UTF-16 code units and an emoji is two of them, so a title cut between the halves rendered a replacement character in the sidebar and the picker, where the character itself should have been.A tool result that arrives before the call it answers is now paired with that call by the LangGraph Bot, as the sibling Bots already did. Read back from the durable thread store the result arrives first, which is a payload no provider accepts: a tool message with no preceding call, then a call with nothing following it. The model answers that with silence rather than an error, so the Bot stopped responding for the rest of the conversation.
Pressing Stop now stops the computer even when the desktop worker never collects the instruction. A stop was queued with no timeout and the worker was the only thing that could ever remove it, so a worker that stopped polling left the entry in memory for the life of the process and the Host access panel showed an operation that could never finish, growing by one per press. Pressing Stop a second time also withdrew the first Stop before the desktop could collect it, and rejected a request that nobody was waiting for, which the server treats as fatal. A desktop that reconnects within the operation timeout is still told to stop.
A computer refuses the cloud metadata address written through the NAT64 prefix
A Bot's computer is now refused the cloud metadata address when it is written through the NAT64
prefix (64:ff9b::a9fe:a9fe is 169.254.169.254), under every network policy including allow-all.
Only the plain and IPv4-mapped spellings were refused, so on a network with a NAT64 gateway the
metadata endpoint was one rewrite away. Browsing already refused this spelling; the computer's
filter now agrees.
?sslmode=require on DATABASE_URL now connects to a managed database
A deployment pointed at RDS, Cloud SQL or Azure Database could not start. The server sent
sslmode to Postgres as a connection parameter instead of turning TLS on, so the connection went
out unencrypted and was refused with no pg_hba.conf entry for host ... no encryption, the very
error the Helm chart's README says ?sslmode=require avoids. Migrations were unaffected, which is
why a deployment got as far as a migrated database and then crash-looped. sslmode=require now
encrypts the connection, and sslmode=disable turns TLS off. sslmode=verify-full, with an
optional sslrootcert, checks the certificate on Bun 1.4 and later and is refused on Bun 1.3,
which connects to any certificate. verify-ca, prefer and allow are refused with a message
naming the modes that work.
A coworker the message speaks to is routed to without asking a model
Addressing a coworker by name went to the intent router like any other message, so the deployment
paid a model call to be told what the person had already said, and sometimes was told something
else. A message that speaks to a coworker by its full name now routes straight to them: it opens
with the name ("Risk Analyst, please check this"), names it with @, or asks it ("ask Risk Analyst
to review this"). It is recorded as matched a coworker’s name in the message with
viaNameMatch: true on the same channel.routed row. A name in passing ("don't send this to Risk
Analyst") and a word that only ends a name ("review this contract", "my meeting notes") still go
to the router. When the message addresses more than one coworker, or two share the addressed name,
it is refused with distinct labels, and the composer keeps the draft and asks the person to choose
instead of starting the default coworker. Explicit picker choices still use viaMention: true.
A Bot's turn in a group is no longer offered coordination tools it cannot call
A Bot answering another Bot in a group conversation was offered ask_person, and message_bot
when hops allowed it, but every call was refused with "This run no longer has permission to
coordinate work in this conversation" and an mcp.callback_refused row nobody had caused. A run is
now offered these tools only when a call from it would be allowed, so that turn is offered neither.
A call that is refused anyway, from a schema offered earlier, is still refused and audited.
0.1.0
Before upgrading. Eight things change for an existing deployment:
- Automatic Learning is on unless an administrator saved it off. It does nothing until a Learning container is assigned; see below.
- A Bot's computer refuses the network until the server pushes its policy. A computer run without
an API server can set
EGRESS_POLICY_REQUIRED=0for the old behaviour. - The upgrade runs migrations
0042_user_preferences,0043_plugin_logos,0044_voice_sessions,0045_channel_activity_source,0046_automatic_learning,0047_agent_pinning,0048_coworker_parity,0049_coworker_parity_lanes,0050_review_fixesand0051_routine_enabled_at. - An existing Windows clone checks text files out with LF only after
git rm -r --cached . && git reset --hardon a clean tree. - The signed-in app shows a bar offering CopilotKit's help self-hosting OpenBot, unless the
deployment is on a paid Intelligence plan. Set
OPENBOT_SELF_HOST_BANNER=falseto remove it for everybody. - An egress rule with a malformed IP range, such as
10.0.0.5/, used to be read as/0and allow every IPv4 address. It is now refused, and a saved network policy that contains one is refused as a whole: the Bots under it fall back to an allowlist with nothing on it, so they reach nothing until the rule is corrected under Admin → Enterprise.
A group reply the owner allows still reaches the Bot it names
A reply held until its owner allowed it to be shown in a group was written into the transcript and then stopped. The same reply allowed immediately was handed to the Bot it named. Allowing it now hands it on the same way.
Before upgrading. Four things change for an existing deployment:
The app offers help self-hosting OpenBot, until you close it
A slim bar at the top of the signed-in app links to CopilotKit's engineers for help self-hosting
OpenBot. Closing it is saved to your preferences, so it stays closed on every device. A deployment
on a paid Intelligence plan (pro, team, team_self_hosted or enterprise, or a licence bought
through AWS Marketplace) never shows it; any other plan, or an entitlement that cannot be read,
shows it. A fork running OpenBot for its own organization hides it for everybody with
OPENBOT_SELF_HOST_BANNER=false.
A request to the approvals API that is not JSON answers 400
A body that could not be parsed as JSON, sent to any approvals route that reads one, such as
PATCH /api/approvals/preferences or POST /api/approvals/rules, answered 500 with the parser's own
message. It now answers 400 "Supply a valid request.", as the delivery routes do.
Syncing a memory source a policy refuses says why
When a connected app's policy refused the read behind a memory source's sync, POST /api/memory/sources/:id/sync answered 503 "Memory is unavailable. Try again.", although the
refusal's own sentence was already saved on the source. It now answers 400 with that sentence, as
the plugin routes do for the same refusal.
@Ops Lead in a group addresses Ops Lead, not Ops as well
In a group conversation, a reply naming @Ops Lead also addressed a Bot called Ops, because the
shorter name matched at the same @, so both answered. An email address addressed a Bot by its
domain: [email protected] reached a Bot called Sam. Where two names start at the same @, only the
longer one is now addressed, and an @ straight after a letter or digit is not a mention.
A webhook with many long top-level fields no longer stops the server
A trigger's event is cut to 32 KiB before it is recorded, keeping each top-level text field up to 1000 characters and an excerpt of the rest. A flat payload whose fields alone came to more than that, such as forty 1000-character fields, left the excerpt nothing to give up, and the loop trimming it never ended. That loop runs on the server's only thread, so every request stopped being answered. The kept fields now get at most half the space, and the rest is still in the excerpt.
A malformed IP range in an egress rule is refused instead of widening the rule
An egress cidr rule written 10.0.0.5/ was stored as 10.0.0.5/0, which is every IPv4
address, so a typo for one host opened an allow-list to all of them. /0x8 and 10.0.0.0/8/9 were
accepted the same way. A zone id such as fe80::1%eth0 was accepted too, and then threw from the
filter on the first connection that policy judged. Each is now refused when the rule is saved, with
the sentence a malformed range already got. A rule like this saved earlier matches nothing.
Deleting a channel twice is recorded once
A second DELETE of the same channel, from a retry or a second tab, still answers 204 as before.
It no longer tells every member again, and no longer writes another channel.deleted row to the
audit trail for a deletion that did not happen.
A Bot's saved reply in a group is no longer replaced by a later error
In a group conversation, a Bot's reply was saved, then handed on: to Activity, to any consent
cards, and to the Bots it named. A fault in that hand-on, such as the audit trail being
unreachable, wrote the error's text over the saved reply and marked it failed, and a retry did not
bring the reply back. The reply now stays as saved, the fault is logged as
group-turn-after-reply-error, and any consent cards or handoff the fault interrupted are still
posted.
The egress filter reaches an IPv6 upstream proxy and asks it for IPv6 hosts correctly
An upstream proxy configured at an IPv6 address, such as http://[fd00::1]:3128, could not be
reached: the filter handed the address to the socket with its brackets, and the socket looked it up
as a name. A CONNECT to an IPv6 host was also sent to the upstream without the brackets an
authority needs, as CONNECT ::1:443. Both now work.
The Helm chart configures Slack, Teams, text messages, push, SCIM, inbound email and OpenTelemetry
These settings had no chart values and could only be passed through config.extraEnv. They now have
their own: config.opentag, config.sms, config.push, config.deliveryPublicUrl, config.scim,
config.inboundEmail and config.otel, with the OpenTag secret, the Twilio auth token, the Expo
access token, the SCIM bearer tokens and the OpenTelemetry headers under secrets (or an existing
Secret or store, by key). The install refuses what the server would refuse at boot, such as an
OpenTag secret under 32 characters or a partial set of Twilio settings. With none of them set, the
chart renders exactly as before, so a deployment already passing these through config.extraEnv
keeps working unchanged until it moves them across.
A coworker at its own endpoint can hand work to another Bot
A grant letting a remote Bot (a coworker at its own endpoint) hand work to another Bot was accepted and stored, but the grant read kept only built-in Bots, so the remote Bot was never
offered message_bot and a call it made anyway was refused as not granted. The read now counts a
grant whatever the Bot's type, so a remote Bot hands work on through the same signed callback, grant
check, caps and audit rows as a built-in one, to a built-in Bot or to another remote Bot. The
coworker's handoff panel now offers it the same switches.
A channel cursor with a malformed time reads as the first page, not a 500
GET /api/channels only checked that a cursor's time was a string before casting it with
::timestamptz, so a hand-edited or corrupted cursor such as {"recency": "not-a-date"} answered
500. A time that is not the UTC timestamp the list writes now reads as the first page, the way every
other malformed cursor already did.
A playground component's Published switch publishes its source too
The Published switch on an admin component page called the generic publication endpoint for every kind. For a browser-authored component that endpoint promoted the description and marked it published without copying the playground draft, so Bots were offered a component the renderer could not draw. Playground components now publish and withdraw both rows in one transaction; a missing or empty description or HTML is refused instead of leaving a half-published component, and repeating an unchanged publish no longer advances the revision.
A proxy password containing % no longer stops every shell command
A proxy password with a % that does not start an escape, such as p%zz, made decoding it throw.
- In the computer's shell, which strips proxy credentials before every command, every
/execfailed as a result. - Resolving a Bot's egress proxy failed the same way.
Such a password is now taken as written, and it is still kept out of the shell's environment.
Revoking a credential twice says so, instead of answering a server error
Revoking a credential that was already revoked, or that does not exist, now answers 404 with the reason. Rotating one that is gone answers 404, and rotating one that is revoked or does not match the key answers 409. Before, each answered a plain-text 500, as if the deployment were broken; a double click on Revoke was enough to cause it. The refused-rotation audit row is written as before.
The channel list no longer skips channels made in the same millisecond
The channel list's page cursor kept the last channel's time to the millisecond, while PostgreSQL keeps it to the microsecond. Channels later in that same millisecond, as a package sync or an import makes them, sorted after the cursor and were on no page. The cursor now carries the time to the microsecond, as the audit trail's cursor already did.
A package skill's slug has the same shape as one made in the app
The skills screen, the skills API and the store all accept a slug of 2 to 40 lowercase letters,
digits and hyphens that starts and ends with a letter or digit. skills.yaml accepted any length
and a trailing hyphen, so a package could seed a, a- or a sixty-character slug that nobody
could then edit. A package with such a slug is now refused at load, with a sentence naming it.
Every slug in examples/fintech already has the shape.
A tenant package that repeats itself is refused by name, instead of failing at boot
Validation now refuses each of these, with a sentence naming the file and the repeated id:
- A skill named twice by one agent, or an agent listed twice in one channel's
permitted_agents. Before, the server stopped at boot with a raw SQL error. - An agent id repeated within
agents.yaml, a channel id withinchannels.yaml, or a skill slug withinskills.yaml. Before, the last entry silently won, though two files declaring the same agent were already refused. - A remote agent left blank in
agents.yamlbut declared with an endpoint underagents/was dropped from every channel that named it. It is now treated as declared.
start.sh and stop.sh see their own processes on Windows
In Git Bash on Windows, which has no lsof, pgrep or pkill, every process and port lookup in
the two scripts came back empty.
bash scripts/stop.shreported the app, the routine worker and the API server as not running, and left all three up.start.shcould not see a port held by another process.start.shstarted another routine worker on every rerun, then reported that the one it had just started "did not stay up".
Where those tools are missing on Windows, the scripts now ask PowerShell, which ships with Windows. Everywhere the tools exist they are used exactly as before.
The supervisor and the Python Bots compare their tokens in constant time
The supervisor compared its bearer token with a plain string comparison, and the eleven Python Bots compared the shared agent token as text, which answered 500 rather than 401 on a header carrying a non-ASCII character. Both now compare bytes in constant time, as the server and the computer already did. A wrong or missing token is refused exactly as before.
A clone on Windows builds an image that starts
On Windows, where Git converts line endings by default, a clone checked every text file out with
CRLF. docker build copied the s6 service files into the image that way, so a service's type
read longrun\r and its scripts stopped on set: -: invalid option, and bun run format:check
failed on every file. .gitattributes now checks text files out with LF on every system. An
existing clone with nothing uncommitted picks this up after git rm -r --cached . && git reset --hard.
A routine switched back on gets a fresh count of failures
A routine that fails ten times in a row is switched off, and someone has to switch it back on.
- Before: the failure count ignored that, so the first failure after re-enabling counted as the eleventh. The routine was switched straight off again with "failed ten times in a row", and the first-failure message never appeared.
- Now: failures are counted from when the routine was last switched on, recorded in a new
routines.enabled_atcolumn. The migration sets it to the time of the upgrade, so any failure streak already under way starts again from zero at that point. Adds migration0051_routine_enabled_at.
Generated workspace files can be downloaded intact
GET /api/computers/:botId/files/download?path=... streams a generated file as an opaque
attachment instead of returning the 64 KB UTF-8 text extract. Downloads use the separate
computer_download_file / download_file permission, remain confined to the Bot workspace, are
capped at 100 MiB with 413, and are recorded on the computer audit trail. Switching off Cloud
computer use under Admin → Enterprise refuses downloads as it refuses reads. Existing read, list
and write APIs are unchanged.
Bots work as coworkers
A Bot can now carry on without anyone watching it. It runs standing Responsibilities fed by schedules, signed webhooks, GitHub, Linear, Sentry, PagerDuty, inbound email and Slack messages, drives its own computer while the app is closed, and keeps its browser profile, cookies and files across restarts. Its questions and approval requests reach the person who owns the conversation in Slack or Microsoft Teams (through OpenTag), by text message or by push, and the conversation resumes when they answer; charts reach Slack and Teams as native charts. Reachability links each of those places to a conversation.
Approvals become one personal flow across the browser, connected apps, shell, files, the host and remote Bots, with custom rules, auto-review and host command modes (Approvals). Bots can message each other, share a group conversation with attributed speakers, and be published to teammates as Team Bots. Memory imports facts from connected apps with their source, and optional background research suggests next steps. A browser demonstration can be recorded and turned into a skill. Administrators get capability toggles, SSO-required sign-in, SCIM, network egress policy, action recording, OpenTelemetry export, and Passwords with private sign-in requests.
Upgrading runs migrations 0048_coworker_parity, 0049_coworker_parity_lanes and
0050_review_fixes.
A Bot's computer refuses the network until its policy arrives
A computer used to allow every connection until the server had pushed its Bot's network policy,
which left up to 30 seconds of unfiltered access after every wake. It now refuses until the policy
arrives, and the server pushes it as the computer wakes. Cloud metadata and link-local addresses are
refused in every mode, including allow_all, and the browser's WebRTC traffic now goes through the
filter instead of around it. A computer run without an API server can set
EGRESS_POLICY_REQUIRED=0 to keep the old behaviour.
Parallel Search is in the plugin catalogue
Two catalogue entries reach Parallel's public-web search and extraction at
https://search.parallel.ai/mcp: Parallel Search, anonymous with provider-managed limits, and
Parallel Search (API key), which sends a deployment credential as a bearer token. Nothing is
granted automatically. When a Bot holds both web_search and web_fetch, the built-in Bot guidance
describes them for public-web research, and the fintech example's Research Desk ships a
research-public-web skill that declares them. See
Public-web research with Parallel.
lodash-es is pinned to the patched 4.18.0
A root overrides entry pins the transitive lodash-es to 4.18.0, the patched release, wherever a
dependency pulls it in.
Provider and Bot lookups ignore inherited object properties
Unknown names such as constructor and __proto__ no longer return an inherited
JavaScript object as a provider or Bot entry. Unknown providers return no spec, and
missing Bots raise the existing startup error. Configured providers and Bots are unchanged.
A malformed % in a stream URL no longer returns a 500
A request to /api/computers/<id>/stream whose id held a broken percent-escape, such as %zz,
made the server throw and answer 500. It is now treated as not matching the stream route and goes
through normal routing. Valid ids behave as before.
start.sh names the port to change on macOS
When the API server's or the app's port was held by another process, start.sh was meant to say
which setting to change, such as Re-run with SERVER_PORT=<free port>. On macOS, whose bash is
3.2, the run ended on bad substitution before printing it, because the hint upper-cased the
name with a bash 4 expansion. It is upper-cased with tr now, so the hint prints on either bash.
start.sh starts the Docker services on Compose v5
On Docker Compose v5, bash scripts/start.sh stopped at
1/4 Docker services with failed to get console: provided file is not a console. The script
sends compose's output to /dev/null while its errors still reach the terminal. Compose saw that
terminal, chose its interactive build display, and could not draw it. The script now asks compose
for quiet progress through COMPOSE_PROGRESS, which older Compose versions ignore, so nothing
changes where it already worked.
The skills pages say when the skills could not be read
When GET /api/plugins failed, Agent Skills said "You don't have any skills yet.", Admin →
Skills said "No skills yet.", and opening a skill to edit said "That skill no longer exists, or it
is not yours to edit.", to people who may have written a dozen. They now say the skills could not
be loaded. A list that arrived empty still reads as before, and a failed refetch over a list already
on screen keeps that list.
A coworker can be pinned to the top of the Agents screen
A coworker's Manage tab has a Pin switch beside Hide, and pinned coworkers move into a
Pinned section at the top of /agents. Like hiding, pinning is personal: it changes nothing for
anyone else. It is stored next to hidden_at in agent_preferences as a new pinned_at column
(migration 0047_agent_pinning), and each write sets only its own column, so pinning a hidden
coworker keeps it hidden and it comes back pinned when unhidden. POST /api/agents/:id/pin and
/unpin record bot.pinned and bot.unpinned on the trail, as hiding does.
A hidden coworker can be found again on the Agents screen
Hiding a coworker took it off both lists on /agents, and Unhide is only in the coworker's dialog,
which only its card opens, so a hidden coworker had no way back short of typing its id into the
address bar. The screen now ends with a collapsed Hidden section listing them, each card opening
the dialog as before. It appears only when something is hidden. Hiding still changes nothing for
anyone else, and nothing on the server changed: the screen reads the GET /api/agents?hidden=true
list the server already served.
A connector's own pages say when the plugin list could not be read
When GET /api/plugins failed, a connector's admin page said "Not a plugin", a tool's page said
"This deployment has not enabled that connector.", and a person's connected-account page said "This
is not a service you connect for yourself.", each about a connector that may be added and granted
right now. They now say the list could not be loaded, as the per-Bot grant page beside them already
did. A list that arrived without the connector still reads as before.
Boundaries says when the policy could not be read
When GET /api/computers/policy failed, the Boundaries screen showed its title over nothing, for as
long as it was open. It now says "The boundary could not be read.", or the server's own reason, as
it did before the screen's read moved into a query.
Browser controls are visible in chat and the Computer sidebar
Channel chats and standalone Bot chats now have a labeled Computer button and always-visible Take control or Hand back controls. The same ownership state is shown in the chat, live Computer sidebar, and full-size viewer. Standalone Bot chats can open the current live browser alongside the conversation without losing the selected Bot or chat history.
An administrator cannot grant a skill nobody has written
POST /api/plugins/grants checked that a skill existed for everybody except an administrator, whose
grant was stored whatever it named. A Bot's skills are read by slug alone, so the row waited for
whoever wrote a skill under that name next, and on a Bot the deployment shares that was one person's
instructions answering everybody. It is now refused with "There is no skill called …", as a grant
naming no app already was. Revoking one by hand still works.
A remote Bot keeps answering when it asks for a learned skill that is not there
With Automatic Learning delivering skills, a Bot reached at an AG-UI endpoint (every shipped Bot except a built-in one) ended the whole turn with "Skill is unavailable." in place of an answer when its model asked for a skill by a name the snapshot does not hold, for a file the skill does not list, or sent arguments that were not JSON. A built-in Bot's model is handed that sentence as the call's result and carries on. A remote Bot's model now gets the same result and carries on too.
An app or skill cannot be granted to a Bot that does not exist
An administrator's POST /api/plugins/grants for an app or a skill checked that the app or skill
existed but not the Bot, so a mistyped Bot id reached the insert, failed on the plugin_grants
foreign key, and answered 500 with no body. It is now refused with "There is no such Bot.", the
sentence the bot kind already used, and nothing is stored. Revoking still checks nothing.
A malformed OAuth client is refused with a 400, not a 500
POST /api/plugins/servers/:id/oauth-client called .trim() on the client id and secret without
checking they were strings, so {"clientId": 12345, "clientSecret": "s"}, or a secret of {}, threw
outside the route's try and answered 500. It now answers the same 400 as an empty value, as the
other plugin routes do for their own fields, before the store or the audit trail is touched.
Browser challenges can be handed to a person without losing the Bot's page
Bots pause for actionable browser challenges and resume from a fresh page snapshot after an explicit handback. Requests survive viewer reconnects and distinguish completion from cancellation, expiry, or an interrupted browser session. Managed browsing now uses full Chromium in headless or headed mode. Local API deployments can opt into installed Chrome with dedicated per-Bot profiles, the same in-app viewer, a loopback-only computer endpoint, and host shell execution disabled.
A hidden Bot's app grants stay on the Plugins screens
Hiding a Bot from your own roster took it off the Plugins screens too: its row went from By Bot and from each tool's switches, the counts could read "3 of 2 Bots", and its own page said there was no such Bot. Its grants stayed in force, and nothing on any screen could take them away. The Plugins screens now follow the rule the Handoff panel already does: a hidden Bot is shown when it holds one of the grants the screen is about, marked "Hidden from your roster", and its own page draws its grants. Nothing on the server changed.
Revoking a function from a component that does not exist answers 404
DELETE /api/components/:name/functions/:function was the one grant write that did not check the
component exists. Against a name nobody has, it deleted nothing, answered revoked: true and wrote a
component.function_revoked row naming a component that was never there. It now answers 404 and
writes nothing, as granting a function and withholding a component already do. A function grant
cannot outlive its component, so there is no stored row this stops anybody removing.
A wiped or restarted shared computer no longer leaves refs pointing at the dead page
Snapshots are ordered on the run of the browser that took them as well as the generation, so a computer that is replaced cannot have its old page mistaken for its new one. That ordering was reaching only the deployments that give each Bot its own container or sandbox, because the run was read off the infrastructure and the deployment with one shared computer has none to read.
Two failures followed there, and both are fixed. A snapshot still in flight when somebody pressed Reset brought the wiped page back, and the boundary went on deciding about its elements: a rule about "Confirm transfer" firing on a click nowhere near one, or failing to fire on one that is. And a computer that restarted counted generations from one again, so its first snapshots were dropped as stale and refs kept resolving against a page nobody was on until the counter climbed back past it.
The computer now mints a run for each Bot's browser session, mints a new one when the Bot is reset, and answers which run it is on. Nothing changes for a deployment that already reports one, and a computer too old to answer leaves the ordering exactly where it was rather than refusing anything.
scripts/start.sh no longer needs python3
The runtime health check in step 3 was a python3 heredoc. On a machine without Python, and on
Windows, where python3 is usually the Microsoft Store alias that exits 49, the run stopped there
with the server and worker up and the app never started. The check now runs in Bun, which the
script already requires, with the same output and exit status, and python3 is gone from the
prerequisites in docs/development.md.
An MCP tool that answers with a resource link is no longer read as an empty name
A tool that points at a file or a page often returns a resource_link: a URI, a name, and a
sentence of what it is, rather than the contents themselves. That part was named [resource_link]
and the URI was dropped, so the model was told a link arrived and never shown where it went. A
search that answered with pages produced no page it could open. The URI, name and description are
now read, each on its own labelled line. The URI leads and the name and description are bounded, so
a long name cannot push the pointer past the result cap; a server's title is shown over its name
when it gives one. A part that already carried text is unchanged.
The Microsoft Agent Framework Bot answers on a plain OpenAI key
Picked with an OpenAI key, the Microsoft Agent Framework Bot failed every run with "Connection
error.". Compose writes OPENAI_BASE_URL empty when the choice is a plain OpenAI key, and the
OpenAI SDK only defaults an absent URL, so it was given "" as the address. The Bot now falls back to
https://api.openai.com/v1 for an empty value, as its Anthropic branch already did for
ANTHROPIC_BASE_URL. An OpenAI-compatible endpoint is unchanged.
OPENBOT_ONE_COMPUTER_EACH=false in .env is honoured by start.sh
scripts/start.sh read OPENBOT_ONE_COMPUTER_EACH from the environment alone, so the line that
docs/configuration.md tells people to put in .env was ignored: the supervisor was still started
and the server still told to give each Bot its own computer. It now reads the key as it reads every
other setting, the environment first, then .env, then the default of true.
Skill selection keeps capabilities named across multiple JSON replies
When a model wraps its skill choice in prose or sends a revised JSON object, OpenBot reads each
complete skills list and offers the union of the named skills' granted tools. This also works with
Anthropic's OpenAI-compatible endpoint, which may ignore the request for bare JSON. Previously a
reply containing multiple objects fell back to offering every tool; replies with no valid skills
list still do.
The AG2 Bot answers on a plain OpenAI key
Picked with an OpenAI key, the AG2 Bot failed every run. Compose writes OPENAI_BASE_URL empty when
the choice is a plain OpenAI key, and the OpenAI SDK only defaults an absent URL, so it was given ""
as the address. The Bot now falls back to https://api.openai.com/v1 for an empty value, as its
Anthropic branch already did for ANTHROPIC_BASE_URL. An OpenAI-compatible endpoint is unchanged.
The live screen keeps reconnecting after it has recovered
A dropped live screen retries five times, waiting half a second, then one, two, four and eight, and then asks for Retry. The count of retries never went back to zero after a retry worked, so a screen left open through five short drops over an afternoon gave up on the sixth, although each had recovered within a second. The count now starts over once a reconnected screen shows a frame again, so only five failures in a row end in Retry.
A failed save of a Bot's browser control leaves no copy behind
The computer keeps who holds a Bot's browser, and its handoff requests, in one file per Bot under the profiles volume, written to a temporary file first and renamed over it. When the write or the rename failed, the temporary file stayed, a readable copy of that state beside the real one, and every later failure added another. It is now removed whether or not the save succeeds, as the learning setup and the model sign-in file already do.
Every Bot's provider defaults live in one spec file
shared/model-providers.json now holds the provider facts and the default provider and model of
the thirteen Bots that read it: the three TypeScript Bots through shared/model-providers.ts and the
ten Python Bots through shared/model_providers.py. The Claude Agent SDK Bot does not read it.
BOT_PROVIDER and BOT_MODEL still win over both, and each Bot keeps its existing default,
including Mastra's gpt-4o-mini. Moving a Bot to a different model is one row in one file.
Both loaders check the file against their own list of providers and refuse in the same words, so a
wrong row now stops all thirteen at startup, naming the key, where the Python Bots used to start
clean and meet it at their first model call. The Mastra Bot also refuses a BOT_PROVIDER it does
not recognize (such as google) instead of quietly answering through OpenAI with a different model.
Compose used to substitute gpt-5.5 for agent-langgraph whenever BOT_MODEL was unset, whatever
BOT_PROVIDER named. It now passes the unset value through, so the Bot's own row answers: an OpenAI
deployment keeps gpt-5.5, and a Google or Anthropic one stops being handed a model its vendor has
never heard of. The picked harness in Compose now also receives GOOGLE_API_KEY and
GOOGLE_GENERATIVE_AI_BASE_URL, so a harness picked on BOT_PROVIDER=google has its key.
Automatic Learning, on by default
Every shipped Bot can now contribute completed conversations to a CopilotKit Intelligence Learning container and receive the skills published from it. Admin → Automatic Learning chooses a default container, overrides or excludes individual Bots, and pauses Learning. Chat, channels, routines and handoffs all follow the same settings.
Learning is on unless an administrator has saved it off, and a saved off stays off. It collects and
delivers nothing until a container exists in the Intelligence project and is assigned:
bun scripts/setup-learning.ts creates or reuses one called openbot and writes it to .env, or
set CPK_INTELLIGENCE_LEARNING_CONTAINER_ID (Helm: config.learning.containerId), or enter it on
the Admin page. OpenBot starts and chats without one. Skills are reviewed and published in
Intelligence; nothing is approved automatically. See
Automatic Learning. Adds migration 0046_automatic_learning.
Dictate messages and talk to a coworker in a live voice call
Deployments can configure transcription separately from their Bots' models, with a waveform composer for recording, cancelling, transcribing, or sending speech. Optional OpenAI Realtime and Grok voice adapters add a floating call widget. The live model handles conversation directly and delegates tools and actions to the existing Bot in the same thread. Ending a call saves its transcript and a short summary; later voice calls and typed messages receive that history. Calls start silently, and muting affects the person's microphone. See configuration.
Voice summaries use the configured chat provider, including Anthropic keys and Claude or ChatGPT plan sign-in. Retrying a failed summary refreshes its sidebar preview without replacing newer activity. A call the voice service turns down says why, such as "The voice service is busy. Please retry shortly.", and a call that cannot be saved says "Could not save this voice chat." and stays on its card to retry. Caps on a call's context, captions and answers cut between characters, never inside an emoji.
The Pydantic AI Bot answers on a plain OpenAI key or an Anthropic key
Picked with either key, the Pydantic AI Bot failed every run. Compose writes the endpoint the choice
did not need as empty (OPENAI_BASE_URL for a plain OpenAI key, ANTHROPIC_BASE_URL for an
Anthropic key), and Pydantic AI builds each provider's client from the environment, so the SDK was
given "" as the address. The Bot now removes an empty value before building the model, as
agent-langgraph-agui already does, so the SDK uses its own endpoint. A real endpoint is unchanged.
The Langroid Bot answers on a plain OpenAI key
Picked with an OpenAI key, the Langroid Bot failed every run with "Connection error.". Compose
writes OPENAI_BASE_URL empty when the choice is a plain OpenAI key, and the OpenAI SDK only
defaults an absent URL, so it was given "" as the address. The Bot now drops an empty
OPENAI_BASE_URL before it builds its client, as it already does for an empty OPENAI_API_KEY.
An OpenAI-compatible endpoint is unchanged.
Find older conversations and keep chat preferences across devices
The sidebar loads older conversations as the person scrolls. Settings save the choice to emphasize the agent or thread name in the database, with a preview. Agent directory cards have more space, connected accounts use individual entries with stored app logos, and browser steps appear in a compact expandable group instead of filling the conversation with screenshots.
0.0.15
A model provider's own sign-in can stand in for an API key
OPENBOT_MODEL_OAUTH_FILE names a credential file holding a Google or xAI OAuth grant. Set it and
the server mounts POST /api/model-provider/v1/chat/completions, which answers an ordinary Chat
Completions request using that grant, refreshing the access token 120 seconds before it expires and
again on a provider 401, and persisting the rotation under a lock the writer and the desktop share.
Leave it unset, which is every deployment that does not set it, and the route does not exist.
The caller authenticates with a separate local bearer taken from that file, compared in constant time, never with the provider's own token: a refresh token never leaves the server process. The file itself is refused unless it is a regular file under 64KB owned readable by nobody else, and a Google grant must name a quota project. The upstream host, path and headers are fixed, so nothing a caller sends can redirect the request.
Google is reached through its native generation API rather than a compatibility endpoint, with a translation layer that carries streaming, tool calls and their results, inline images and function-call thought signatures across in both directions. An API-key connection is unchanged and still uses the compatibility endpoint.
A provider 403 no longer reads as an expired sign-in. It usually means a missing project or resource permission, which signing in again cannot fix, so only a 401 now raises "sign in again".
Desktop setup shows progress, chooses its own local ports, and can sign in to a provider
Downloads report transferred bytes, every running step reports elapsed time, and running, completed and failed stages are told apart. Back preserves the connections already entered.
OpenBot now chooses its local ports by binding them rather than assuming them, holds them until the
whole set is settled, and writes them to the deployment's .env so a restart keeps the same
addresses. That covers a port another program holds and a port Windows has reserved, neither of
which the old fixed defaults survived. A port that becomes unavailable between choosing and starting
now says so and asks for another Start, where it previously refused before trying.
Setup can create a CopilotKit project, and offers Google Gemini and xAI as API-key choices alongside
OAuth sign-in. Google sign-in requires this build's own registered desktop client and quota project,
set at build time or by environment variable, and refuses with a message saying so when it has
neither; xAI falls back to a public client and works in any build. desktop/PROVIDER_OAUTH.md
describes what a distributor configures.
A deployment left behind by an earlier installation can be detected and reset from the app, which removes that deployment's database volume and nothing else.
Startup failures keep enough of the log to name the cause, with every secret value redacted, and carry a support link a whitelabel build can point elsewhere.
A Bot's image pull finds the Docker credential helper beside Docker
A Docker install whose credential helper sits next to the docker binary rather than on the desktop
app's own PATH failed the pull with a PATH error naming the helper. The directory holding the
resolved docker, and the directory holding what it points at when it is a symlink, are now appended
to the PATH the engine is invoked with. Appended, so an existing helper still wins, and the inherited
PATH is now kept rather than replaced, which it was not before.
OpenBot starts only on the Bun it pins
An installed or cached Bun that is not the pinned version is no longer accepted, on install and on every start, and OpenBot acquires its own copy instead. The version already on the machine is left exactly as it is and simply not used.
Organization sign-in survives a callback that arrives in pieces
The loopback listener that receives an organization or provider sign-in read the callback once and gave up if the whole request had not arrived, and on Windows the accepted socket inherited the listener's non-blocking mode, so a timeout did not apply. A good sign-in could be answered "Sign-in did not match". Both paths now read until the request line is complete, with a real timeout.
Compose file lists separate correctly on Windows
The separator between Compose files fell back to : everywhere, which is right on macOS and Linux
and wrong on Windows, where a drive letter contains one. It now follows the platform. This is
reachable on every platform now that a port overlay is passed, where before it was macOS only.
0.0.14
A tool cannot be granted for an app this deployment has not added
Granting a Bot a connector's tool checked only that the person asking was an administrator, so a grant naming an app that was never added was stored and then invisible — the page that reports a grant nothing advertises is built from the connector's own row, and there was none. Adding that app later put every such grant straight onto its Bots, with nobody having granted anything and nothing in the trail saying so. The grant is now refused, naming the app. Taking a grant away is unaffected, so a dead row an administrator can see is still one they can remove, and a tool a connector has stopped advertising can still be granted: what a vendor lists today is not what somebody decided yesterday.
The LiteLLM Bots keep the chosen provider on a model name that contains a slash
A model name the endpoint publishes with a slash in it — qwen/qwen3-8b, or the docs example
openai/gpt-5.6-terra — was treated as already carrying a provider. LiteLLM then took the first
half as the provider and sent only the rest, so a compatibility endpoint either failed with
LLM Provider NOT provided or received gpt-5.6-terra instead of the namespaced name. The ADK,
Strands, Agno, LlamaIndex and CrewAI Bots now keep the chosen provider in front, and the whole
model name reaches the endpoint.
A Google Drive shortcut is read as the file it points at
Search and recent files return shortcuts as ordinary hits, and reading one by that id was refused
as a binary application/vnd.google-apps.shortcut. A document somebody had starred or filed as a
shortcut — the usual way a shared drive file is kept at hand — could be named and not opened. The
connector now follows the target once and reads that file the same way it would have if search had
returned it directly. A shortcut that names nothing, or another shortcut, is still declined.
An MCP tool that answers in structuredContent is no longer read as empty
A tool that declares an output schema often puts the answer in structuredContent and leaves the
content list empty. That empty list was reported as "nothing was found", so the model filled the
gap from memory while the vendor had answered. The structured object is now read when the content
list had nothing to say. A tool that already sent text is unchanged.
The slash no longer names the provider on those five Bots, so a BOT_MODEL that relied on it to
reach somewhere other than BOT_PROVIDER is now read as part of the model name: bedrock/…,
azure/… and openrouter/… reach the provider BOT_PROVIDER names rather than the one written in
front of the slash. BOT_PROVIDER is the setting for that, and a model name written bare beside it
behaves as it did. The framework Bot agent-langgraph and the Langroid Bot are unchanged, because
neither read the slash that way.
A Bot's computer no longer runs as root on Kubernetes
The image already builds pwuser, chowns /workspace, /profiles and /app to it, and the
all-in-one image drops to it through s6. A computer pod overrides the command to run the browser
process alone, so it never reached s6 and ran as uid 0. It now runs as pwuser in both the modes
this chart runs a computer in, shared and sandbox, with HOME and BUN_INSTALL set the way s6
sets them. BUN_INSTALL moves because its default is root-owned, and bun add in a Bot's shell
would otherwise stop working the moment the pod stopped being root.
Kubernetes only. The Compose and supervisor paths run agent-computer/Dockerfile, which builds
no such user and is still uid 0. That is the rest of the residual #261 named and is not this change.
What it buys, and what it does not. It is not a containment boundary against a Bot's own shell:
the image grants pwuser passwordless sudo for apt-get/apt/dpkg, which escalate to root by design,
and gVisor plus a computer per Bot remain the actual boundary. Nor does it change which Pod
Security Standard the pod meets: runAsNonRoot is a restricted control, not a baseline one,
and restricted also wants allowPrivilegeEscalation: false, capabilities.drop: [ALL] and a
seccomp profile, which are deliberately not set here for the sudo reason above. The pod met
baseline before this and still does not meet restricted after it. What it does buy is the org
policies and admission rules that reject uid 0 outright, that root-owned data stops accumulating
in the volumes, and that a bug yielding a constrained primitive lands as 1001.
Before upgrading an existing release, two things. The kubelet applies fsGroup only where the
volume plugin says it can: the EBS, PD and Azure Disk CSI drivers do, hostPath does not, and
hostPath is what rancher/local-path-provisioner hands out by default, which is the default
StorageClass on k3s. On storage that cannot, the computer now refuses to start and says so, rather
than coming up healthy with a browser profile Chromium silently replaced, which is what it did
before this release. Chown the directory, or set computers.podSecurityContext: null. And an
upgrade run with helm upgrade --reuse-values does not pick up a new key at all, so it keeps
running as root and says nothing; pass the value or drop the flag.
In computers.mode: sandbox, existing Bots keep their old computer. The server copies the pod
template into a Sandbox when it creates one and never updates it, so only Bots created after the
upgrade run as 1001. The server does restart, because the template checksum changes, which makes it
look like the change landed everywhere. The only lever today is reset, which deletes that Bot's
volumes and its logins.
fsGroupChangePolicy: OnRootMismatch is set deliberately. Unset means Always, which walks every
file on every mount; a real Chromium profile is tens of thousands of small ones, and in sandbox
mode that pass would run again on every resume from idle.
Which email domains may sign in, decided by the deployment rather than the provider
Nothing in OpenBot filtered who could sign in. INITIAL_ADMIN_EMAILS decides who is an
administrator once they are in, which is a different question. The providers do not answer it
either: MICROSOFT_OAUTH_TENANT_ID defaults to common, which is any Microsoft account including
personal ones, and Okta has no equivalent setting. So a deployment reachable from the internet
admitted anybody who could complete the flow, as a non-administrator with access to its Bots.
SIGNIN_ALLOWED_EMAIL_DOMAINS, or config.allowedEmailDomains on the chart, names the domains
admitted. It is checked against the address the provider returns, in the same two hooks the removal
deny list uses, so it covers a first sign-in and an account that already exists. A refusal writes a
session.refused audit row naming the reason. Empty means no opinion, so nothing changes for a
deployment that does not set it.
Matching is exact with no wildcards, for the reason AGENT_ENDPOINT_ALLOWED_HOSTS gives:
example.com admits neither sub.example.com nor evil-example.com. Both sides go through the
same IDNA normalisation, so a list may be written @Example.COM. or in punycode and still mean
what it says.
It is a filter, not a boundary, and the deployment is told so. OpenBot does not require a
verified address, and Entra's email claim comes from a directory attribute that the signing-in
tenant's own administrator writes. Two consequences, both now enforced at start-up rather than
documented and hoped for:
- Naming domains while
MICROSOFT_OAUTH_TENANT_IDnames no directory is refused. That iscommon, and equallyorganizations, which Microsoft describes as admitting any work or school account in any directory, andconsumers. Anybody can create a tenant and write your domain into their own user, so the list would refuse the honest and admit the rest while reading as a control. Set your directory GUID. - A list that names nothing, which
SIGNIN_ALLOWED_EMAIL_DOMAINS=@and a stray.both produce, is refused. It is a non-empty list no address can match, and left to run it turns every visitor away with nothing said at boot.
A deployment that names no domains and leaves the tenant multi-tenant warns instead of refusing, because genuinely multi-tenant is a real deployment.
No sign-in cannot be combined with a public address
OPENBOT_SINGLE_USER=true admits every request as one administrator. The flag is how somebody says
they meant that, and it still is. What was missing is the second question: one administrator and no
sign-in is a thing you run where only you can reach it, and nothing checked the address.
It is now refused alongside an OPENBOT_PUBLIC_URL, OPENBOT_APP_URL or TRUSTED_ORIGINS entry
that the public internet routes to, and the refusal names the address it objected to. This is the
rule the chart already applies twice, in validation.yaml, moved to where a deployment that never
goes near Helm is asked it too: .env.example ships the flag on so that a clone runs, and README's
"Deploy it" hands that same .env to docker run, where the only thing separating a laptop from a
server is an address.
Public, not "not loopback", and the difference is most of the deployments this flag has. A home
server at 192.168.1.10, a Tailnet address, a VPN address, openbot.local, a bare hostname with
no dot in it: none of those is loopback and none of them is a stranger's to reach. Refusing them
would refuse the feature's own audience, and the only way out would be to turn off the flag that
describes what the operator is doing. Those run, and warn once at boot that anybody on that network
is the administrator. Loopback is silent. A value that cannot be parsed as a URL counts as public,
because a value nobody could read is not one anybody checked.
Nothing on loopback changes, so the local workflow the flag exists for is untouched, and neither is
the chart's config.singleUser trial mode, which sets no public address. A deployment naming an
external authority through OPENBOT_ORGANIZATION_AUTH_URL is unaffected too: the authority wins
before this is consulted. Explicitly NOT gated on NODE_ENV: the image and the chart both set it
to production for every deployment including that trial, so it says nothing about who can reach
a deployment.
docs/architecture.md, docs/deployment.md and docs/configuration.md all described the old rule
and now describe this one.
The EKS cluster recipe puts the node's IAM role out of a Bot's reach
A Bot has a shell, and a shell reaches whatever its pod reaches, including the instance metadata
service at 169.254.169.254 that hands out the node's IAM role. The NetworkPolicy excepts that
address, but it is off by default and does nothing on EKS until the VPC CNI is told to enforce it,
so the cluster config in the chart README now sets disableIMDSv1 and disablePodIMDS on the node
group, which closes it at the node whatever the CNI is doing.
disablePodIMDS is the line that does the work: it sets the hop limit to 1, and that governs the
IMDSv2 token PUT, so a pod one hop further out than the node cannot get a token. disableIMDSv1 is
written beside it to say so out loud rather than to change anything, because eksctl defaults it to
true and sets httpTokens: required for either flag. Pods on the cluster network are covered; one
running with hostNetwork: true is on the node and is not.
It costs something, and the recipe says so. The EBS CSI driver reads instance metadata from
IMDS, and its own documentation asks for a hop limit of 2 or greater in a containerized environment.
A hop limit of 1 also rules out MutableCSINodeAllocatableCount, which requires IMDS to be the
driver's metadata source. Take these two lines out if you need that.
Nothing in OpenBot wants pod-level IMDS: the chart reaches AWS through IRSA. Documentation only; no chart template changed, and an existing cluster is unaffected until its node group is recreated.
A large text file says so on the composer before it is sent
The model reads the first 120,000 characters of an attached text file and the rest is dropped. The part said so to the model and nothing said so to the person attaching it, so a 1MB CSV was answered from roughly a tenth of itself with nothing on screen to explain the answer. A staged file over that ceiling now carries "may be cut" beside its size, with the exact number on hover. Warned, never refused: the whole file is still uploaded and still stored.
Whether a file is text is decided by what the server read in its bytes, not by what the browser called it, so a file the browser labelled an image and the server read as text is warned about too. That is the file the old reading would have missed.
ADK and Langroid Bots can call the tools OpenBot supplies
Both answered text prompts on an OpenAI key and neither could reliably use the tools the deployment
supplies them, so a Bot on either harness could talk but could not act. ADK now registers the
documented AGUIToolset. Langroid now sends each run's tool schemas and its complete message
history, tool results included, so a tool's answer reaches the model that asked for it. Each run
keeps its own tool and history state.
Built-in Bots carry a model provider's sign-in failure through as itself
A built-in or LangGraph Bot whose model credential had expired ended the run as a generic failure,
which reads as the Bot being broken. The run now ends with OPENBOT_MODEL_AUTH_REQUIRED and says to
sign in to the model provider again.
The built-in Bot's tool loop also moved to the server, which owns the grants that decide what a tool may do. The harness is given model input alone, and a tool result is resolved against the call that produced it, so a Bot can carry a multi-step task across several tool calls rather than losing the thread after the first.
A deployment can name an organization authority that decides who it admits
OPENBOT_ORGANIZATION_AUTH_URL points at an OpenBot deployment configured with Google, Microsoft or
Okta, which verifies who somebody is and what roles they currently hold. It is separate from any
Intelligence connection, and the authority keeps its own secrets.
Naming one settles the sign-in question by itself: it wins over OPENBOT_SINGLE_USER, so a
deployment carrying a leftover single-user flag admits verified people rather than admitting
everybody as one administrator.
A coworker can be a file of its own
The example package declared every coworker in one agents.yaml, so adding one meant editing a file
somebody else was editing too, and handing somebody a coworker meant handing them a fragment to
paste into the middle of theirs. A package may now also keep a coworker per file in an agents/
directory beside agents.yaml, and both are read. A package that keeps everything in agents.yaml
loads exactly as before. A file holds the coworker on its own or a list under agents:, only
.yaml and .yml are read, and files are read in filename order. Two declarations of the same id
stop the server and both files are named, rather than one quietly winning on the order a directory
was listed in. The directory is in the package checksum, so a coworker added or edited there is a
package change a running deployment notices.
Ten more example coworkers, each doing one job
The example package shipped three coworkers, which is enough to prove the format and not enough to
give anybody ideas, and writing a role_description cold is the part that decides whether a
coworker answers usefully or vaguely. Ten more ship in examples/fintech/agents/, one file each:
reading an expense claim against the policy as written, turning a meeting note into the follow-ups
actually in it, drafting release notes from what shipped, triaging a support ticket, answering a new
starter from the handbook, writing a brief that names what it could not find, writing up an
interview with question, answer and observation kept apart, handing an on-call shift over from the
record, assembling what is known before a renewal decision, and grouping customer feedback into
themes it can cite. Each says what the job is, what the coworker must not do, and what to say when
it cannot find something. They grant nothing: a coworker names skills, a skill names tools, and what
it may call is what an administrator has granted. Delete the ones you do not want.
Built-in and Mastra Bots can run on Anthropic API keys
The example built-in Bots and the Mastra Bot now use the selected model provider instead of
assuming OpenAI. A deployment with BOT_PROVIDER=anthropic, BOT_MODEL=claude-sonnet-4-5 and an
Anthropic key routes built-in model calls, tool selection and Mastra runs through Anthropic's native
API. Source startup no longer waits for the unused OpenAI-only sample when Anthropic is selected.
The Agno Bot answers on an OpenAI key
Picked with an OpenAI key, the Agno Bot failed every run before reaching OpenAI. Agno sends a
temperature and a top_p with each request, and LiteLLM refuses both for gpt-5.5, the model
Compose passes when the setup screen names none, so the run ended in UnsupportedParamsError. A
parameter the model does not take is now dropped instead, the way the LlamaIndex Bot already does
it. The Anthropic key and an OpenAI-compatible endpoint behave as before.
The Pydantic AI Bot starts on an Ollama model named with its tag
Ollama names every model with a tag after a colon, as in llama3.1:8b, and that is the name the
setup screen passes on for an OpenAI-compatible endpoint. The Pydantic AI Bot took any colon in the
model's name to mean the name already carried a provider, so Pydantic AI read llama3.1 as one,
refused it as unknown, and the Bot never started. A model's name now carries a provider only when it
begins with the chosen provider's own, as in anthropic:claude-sonnet-4-5.
The Langroid Bot starts on an Anthropic key
Picked with an Anthropic key, the Langroid Bot exited on startup asking for an OpenAI key. It names
a model from any provider but OpenAI through litellm, which its image did not install, and Langroid
builds an OpenAI client for such a model all the same, from the OPENAI_API_KEY Compose writes
empty when the choice was not OpenAI. The image now installs Langroid's litellm extra and an empty
OpenAI key is treated as none, so the Bot starts and answers with the Anthropic model chosen.
The AG2 Bot answers on an Anthropic key
The AG2 Bot built an OpenAI client whatever the setup screen chose, and read BOT_MODEL but never
BOT_PROVIDER. Picked with an Anthropic key, every run failed asking for an OpenAI key, because
Compose writes that one empty when the choice was Anthropic. It now reaches Anthropic through AG2's
own Anthropic client when that is the provider chosen, and OpenAI or an OpenAI-compatible endpoint
as before otherwise.
The Microsoft Agent Framework Bot starts on an Anthropic key
The Microsoft Agent Framework Bot built an OpenAI client whatever the setup screen chose, and read
BOT_MODEL but never BOT_PROVIDER. Picked with an Anthropic key, it exited on startup asking for
an OpenAI key, because Compose writes that one empty when the choice was Anthropic. It now reaches
Anthropic through Agent Framework's own Anthropic client when that is the provider chosen, and
OpenAI or an OpenAI-compatible endpoint as before otherwise.
0.0.13
Fresh desktop setup installs its runtime before sign-in
Desktop setup installs local software before asking for an AI connection. Fresh Mac Podman installations no longer duplicate stack port bindings. The shared installer downloads verified prebuilt Bun binaries without developer tools; Linux setup also installs its native Podman runtime and certificate bundle. (#604)
Ctrl+B shows and hides the sidebar on a layout that does not write Latin letters
The sidebar toggle's tooltip names Ctrl+B, or ⌘B on a Mac, and the shortcut was recognised by the character the key writes. On a Russian or Greek layout the B key writes "и" or "β", so the shortcut did nothing there. It is now read the way the app's own shortcuts read it since Shift+N was fixed for the same layouts: from the physical key when the layout writes a character outside ASCII there.
Scrolling a Bot's browser no longer scrolls or zooms the page around it
While somebody drives a Bot's browser, a turn of the mouse wheel over its screen is sent to it, and the screen was meant to keep the wheel from also acting on the app. React attaches its wheel handler as a passive listener, which a browser does not allow to do that, so the wheel scrolled the frame holding the Bot's screen along with the Bot's page, and Ctrl with the wheel zoomed the app. The wheel is now handled by a listener that can hold it, so it reaches only the Bot's browser.
Typing into a Bot's browser no longer triggers the app's own shortcuts
While somebody drives a Bot's browser, every keystroke is sent to it. The app's shortcuts listen for keystrokes too, and they heard each one first, so typing a capital N into the Bot's browser, as in "New York", started a new chat and took the person away from the Bot mid-word, and Ctrl+B there also showed or hid the sidebar. A keystroke sent to the Bot's browser now reaches only the Bot's browser. Escape still closes the view, and the paste shortcut still pastes.
The Python LangGraph Bot on Anthropic answers after a skill was picked
A skill somebody picks reaches the Bot as a system message just ahead of their message, and it
stays in the conversation. Anthropic takes one system prompt, and its LangChain integration refuses
a system message that comes after a turn of the conversation, so with BOT_PROVIDER=anthropic
every run in that conversation failed from then on, before the model was asked. On Anthropic the
Python LangGraph Bot now puts every system message ahead of the conversation, in the order given,
where the integration joins them into its one prompt. Runs on OpenAI and Gemini are unchanged.
The LangGraph Bot answers on Anthropic and Gemini
With BOT_PROVIDER=anthropic or BOT_PROVIDER=google, the LangGraph Bot answered nothing: every run
ended in an error before the model was asked. Those two providers take one system prompt, at the top,
and the Bot handed its model several: its own guidance, the context the app sends, and the
coworker's standing role, which the server puts at the head of every run. The provider's LangChain
integration refused the second one. On those two providers the Bot now folds them into one system
prompt, in the same order, and a skill picked for a message joins it. Runs on OpenAI are unchanged.
The proof-of-concept Bot reads a model name set with whitespace around it
A BOT_MODEL carrying a leading space reached this Bot as it was written. Its startup check refuses
gpt-5.6-*, which rejects function tools on the API this Bot speaks, and that check matches from the
start of the name, so a padded one walked past it: the Bot started, reported healthy, and answered
nothing at all on the first turn that used a tool. An empty value was read the same way and asked the
provider for a model with no name. Both now fall back to the default, and the name is used trimmed.
.env was never a route to this — Compose, Bun and the desktop shell each strip the value first — so
it reached only deployments that set the variable directly, such as a Kubernetes manifest or
docker run -e.
Pasting into a Bot's browser works on a layout that does not write Latin letters
While somebody drives a Bot's browser, Ctrl+V or Cmd+V is left to the local page so its paste event can send the clipboard text across. The shortcut was recognised by the character the key writes, and on a Russian or Greek layout the V key writes "м" or "ω", so the keystroke went to the Bot's browser instead and nothing was pasted. The V is now read the way the app's own shortcuts read it since Shift+N was fixed for the same layouts: from the physical key when the layout writes a character outside ASCII there.
Reading a large file from Google Drive no longer downloads all of it
read_file_content shows a Bot at most the first 20,000 characters of a file, but it downloaded the
whole file and held it in memory before cutting it. A 200 MB text file raised the server's memory by
more than 600 MB for one call, on the process that serves everybody else. The connector now stops
reading once it has more than it can show and cancels the rest of the download. What the Bot is shown
is unchanged, except that the note on a cut file no longer gives the file's full length, which is no
longer known.
A Bot reads the text an MCP server returns as an embedded resource
A tool result can carry an embedded resource, and a text resource holds content, such as a file the
server read. The MCP connector passed text parts to the Bot and named every other part, so a text
resource reached the model as [resource] and its contents were dropped. GitHub's MCP server answers
get_file_contents for a text file this way: the Bot was told the download worked and never saw the
file. The text of an embedded resource is now passed on like a text part. A resource that carries
bytes is still named.
The Google Drive connector reaches files in shared drives
Drive leaves shared drive items out of any files.get or files.list request that does not say it
supports shared drives, and none of the connector's requests said so. A document the person could
open in a shared drive was "File not found" to get_file_metadata and read_file_content, and never
appeared in search_files or list_recent_files. Those requests now say they support shared drives,
and the listings ask for shared drive items. Listings keep Drive's default user scope rather than
searching every shared drive.
Google Drive search and recent files leave out what is in the trash
Drive's files.list returns trashed files unless the query excludes them, and neither search_files
nor list_recent_files did. A document somebody had thrown away came back to the Bot as a match or
as a recently changed file, with nothing in its line to say it was in the trash, so the Bot could
answer from it as though it were current. Both now ask Drive to leave the trash out. Reading a file by its
id is unchanged.
New conversations are still named once some older ones could not be
Every pass of the job that names conversations offered at most twenty of those still without a name. A conversation it had tried and could not name, for example because the model answered with no text or the conversation opened with only an attachment, keeps no name, so it stayed among those twenty and took a place on every pass, although offering it again did nothing. Once enough of them had built up, a new conversation could miss out on every pass and keep showing its plain name in the sidebar. A pass now skips any conversation that the job already holds work for, so new ones get a place. One it could not name is still tried again later, as before.
An offboarding one app refuses still records the apps that answered
Removing somebody withdraws each brokered account they connected. When the broker refused one of
those apps, the whole act stopped before anything was recorded: apps already withdrawn at Composio
kept their composio_connections row and left nothing on the trail saying the account had ended,
and the retry that #574 made the recovery then asked again, was told there was nothing to withdraw,
and wrote vendorRevocationRequested: false about a withdrawal this deployment had asked for and
got. Each app is now asked, recorded with the answer it actually gave and its row removed, and only
the apps that were refused are left standing for the retry. The act still fails and still answers
500, so a refusal is as loud as it was.
Paging the audit trail no longer skips rows written in the same millisecond
GET /api/admin/audit-events hands out a nextCursor built from the last row's timestamp, which the
server read at millisecond precision while PostgreSQL keeps microseconds. The cursor therefore named a
moment just before that row, and the rows the next page should have started with, written earlier in
the same millisecond, were on no page at all. Anything that walked the trail page by page could miss
them without any sign of it. The cursor now carries the row's full timestamp. A cursor issued before
this change still reads.
The New chat shortcut works on a Russian or Greek keyboard layout
Settings lists New chat as Shift+N, and the app matched the character the keystroke wrote. A layout that writes another script has no key that writes an N: Shift and the N key write "Т" on Russian and "Ν" on Greek, so the shortcut never fired there. When the character is not ASCII, the app now reads the physical key instead. A layout that writes Latin letters, such as Dvorak, still goes by the letter.
Enter that confirms a typed character no longer saves a name, a rule or a wizard step
Japanese, Chinese and Korean are typed through an input method, where Enter confirms the character being built. In three fields that Enter also acted: editing a coworker's name or title saved it with the character still unconfirmed, the new-coworker wizard moved on to its next step, and a boundary rule was saved into the policy in force. Those fields now wait for the character, the way the chat composer already does, and an ordinary Enter works as before.
A built-in coworker can be edited where the deployment's own Bot is on localhost
A coworker created as Built in is stored pointing at the managed Bot's address. Editing its name,
title, role or visibility sent that address back as though somebody had typed it, and the server
checks an endpoint it is sent the way it checks a person's. scripts/start.sh puts the managed Bot on
http://localhost:4201/ag-ui, which that check refuses unless private hosts are opened, so every edit
failed with "That address is inside this deployment's own network, so an agent may not live there."
The dialog now leaves a built-in coworker's address where it is stored. A coworker somebody hosts
still sends its own endpoint, as before.
A long page's text is cut between characters, not through one
A navigation hands the Bot the first 6000 UTF-16 code units of the page's readable text. When that limit fell between the two halves of an emoji, the Bot was handed text ending on half a character, which reads as U+FFFD: a broken character that is not on the page. It now stops one code unit short in that case, which is what a control's name and value in a page snapshot already did.
Tool selection reads a skill choice the model wrapped in a code fence
Before a run, the deployment's model picks which of a Bot's skills the message needs, so a Bot holding
many tools is offered only the relevant ones. The request asks for bare JSON, but an endpoint that
ignores response_format, as Anthropic's OpenAI-compatible one does, lets the model fence the object
or lead with a sentence. Every such answer read as no answer, so the Bot was offered every tool it
holds and the audit row said unavailable. The object is now read out of the answer, the way the
router already reads its own. A bare JSON answer is read as before.
A long message reaches the coworker it is for, and is recorded
A message over 10,000 characters, such as a pasted email thread or log, was refused by the router
since it started capping the text it reads. The home composer carries on past a routing that fails,
so the message went to the default coworker rather than the one it is for, and a coworker chosen with
@ or from the To: field started with no channel.routed row. The app now asks the router about the
message's opening, and the whole message still goes to the coworker. Shorter messages route as
before.
Removing somebody is recorded even when retiring what they owned fails
Removing somebody denies their access and ends their sessions, then retires the credentials and brokered connections they had granted this deployment. When that second half failed — a vault or Composio not answering — the removal was already committed but nothing was written to the audit trail, and removing them a second time reported success without retrying it, leaving those connections standing. The removal is now recorded as soon as it takes effect, and removing somebody already removed finishes the retirement that failed.
Removing a connector takes its grants with it
A grant naming a connector's tool outlived the connector. Removing an app revoked every credential and every brokered account and deleted the app itself, and left the grant rows behind, naming a server that no longer existed. Nothing showed them: the page that reports grants a connector no longer advertises reads them off the connector's own row, and there was none. Adding the same app back — which mints the same id, and so the same tool names — put every action it had back on every Bot that used to hold it, with nobody granting anything and no row in the trail saying a grant had been made. An app's grants are now removed in the same step as the app, the removal records which grants it released and from which Bots, and a migration drops the grants earlier removals left behind. Grants for other connectors, and skill grants, are untouched.
A vendor that broke no longer reads as a refusal to a Bot running its own loop
When a Bot that calls tools back from its own process, such as the LangGraph Bots, called a tool whose vendor failed, or hit a fault in this deployment, the answer began "Refused." like a boundary holding. The conversation drew it as blocked and the model read it as not allowed, while the audit trail recorded a failed call. Only a refusal is marked now. A vendor that broke reads "That tool could not be called: …", the way it already did for a Bot running here, and a refusal reads as before.
A Bot running its own loop is told a vendor's error is the vendor's
A vendor that says no by answering with an error, the way an MCP server refuses a call, reached a Bot running here as "The vendor reported an error: …", and reached a Bot calling tools back from its own process, such as the LangGraph Bots, as the bare sentence. Those Bots pass the answer on as they receive it, so their model read something like Google's "The caller does not have permission" as an ordinary result, and could tell the person they had no access rather than that the vendor had refused. Both kinds of Bot are now told the same thing. A result that is not an error, and this deployment's own refusals, read as before.
A long Composio result or failure is cut between characters, not through an emoji
A Composio action's answer over 20,000 characters, and a failure sentence as long, were cut by UTF-16
code unit. When the cut landed inside an emoji or any other character outside the Basic Multilingual
Plane, the text handed to the model ended on half of it: a lone surrogate that JSON carries as a bare
\ud83d and UTF-8 turns into a replacement character. The cut now stops one unit short in that case,
the way the MCP and built-in transports' cuts already do. Anything that fits is untouched, and the
note saying the answer was cut reads as before.
0.0.12
A deployment can broker its Bots into a few hundred apps through Composio
Composio holds a person's connections to a few hundred SaaS apps behind one account. A deployment
that sets COMPOSIO_API_KEY now has that broker: each person connects their own accounts, a Bot is
granted an app's tools the way it is granted any other, and every call is decided and recorded
through the gateway like the rest. Unset, there is nothing to connect, nothing to grant and no
Composio tool for a Bot to call, and the Plugins page says so under More apps rather than
pretending otherwise. See docs/plugins/composio.md.
A skill's grants are removed when it is uninstalled
Uninstalling a skill deleted the skill but left its tool grants, which are keyed by its slug. A new skill created under the same slug then inherited them, and was offered on the Bots the old skill had been granted to with no grant ever made for it. Uninstalling now removes a skill's grants along with it, in one transaction, and an upgrade drops any grants already left orphaned this way.
Malformed requests are refused instead of coerced, and a fail-open is closed
A pass across the write and query surface answers a malformed request with a 400 that names the bad field, rather than coercing it, failing at the store, or letting it through: the plugin server and tool-call endpoints, the admin people search and credential input, skill tools and grant ids, blank route ids on routines, host-access, agents and channels, the routing text length, routine dispatch and page-frame params, and the runtime env, tokens and model content the computer and supervisor read. The app reads these responses more defensively too, degrading rather than throwing on a shape it did not expect.
One of these closed a hole rather than tightening an edge: a skill installed with a non-string entry
in its tools list had that entry silently dropped, so the skill declared nothing and installed as a
success. It is refused now.
Naming a conversation asks the endpoint OPENAI_BASE_URL names, not OpenAI
The job that names a conversation sent its request to api.openai.com whatever OPENAI_BASE_URL said,
while the Bots, the router and tool selection all used the configured endpoint. A deployment behind a
gateway, a proxy or a local model therefore sent its model key, and the opening of every
conversation, to OpenAI; OpenAI refused the key, so no conversation was ever named. The request now
goes to the same endpoint as every other model call. A deployment that never set OPENAI_BASE_URL
behaves as before.
A Bot's question to a person survives a route that fails
Who "a person" is, is a seam a deployment fills in with its own on-call rota or duty desk. If that
route failed by throwing rather than by returning a refusal — a timeout, a 502, a name that does not
resolve — the error came straight back out of the tool, so the Bot's run ended with nothing said to
the person waiting, and no audit row recorded that the question had reached nobody. The Bot is now
told, in a sentence it can say, that nobody could be asked and that it must not claim otherwise, and
an agent.escalation_failed row goes down carrying what the route actually threw. Deployments using
the shipped in-conversation route are unaffected: it cannot fail.
Resetting a Bot's computer while the Bot is acting signs it out
On a deployment with one shared computer, which is what the published image and the Helm chart run by default, a reset takes about two seconds to close the browser before it deletes the profile. A Bot action that arrived in that window started a new browser from the profile about to be deleted, so the Bot stayed signed in to everything until that browser next closed, while the reset reported success and the audit trail recorded the saved state as deleted. A Bot's browser is no longer reopened while it is being closed: the action waits for the reset to finish and starts signed out. Computers the supervisor makes per Bot were not affected.
A long control name or value in a page snapshot is cut between characters
The computer's page snapshot keeps the first 200 UTF-16 code units of each control's accessible name and value. When that limit fell between the two halves of an emoji, the Bot was handed text ending on half a character, which reads as U+FFFD: a broken character that is not on the page, often at the end of a message the Bot had just typed into a text box. The cut now stops one code unit short in that case, the same rule tool results and relayed answers already follow.
A Bot's shell can no longer read the deployment's keys from a neighbouring process
In the all-in-one image the API and the browser ran under one account, and a Bot's shell — a child
of the browser — could read a same-account process's environment through /proc, whatever its own
environment had been scrubbed to. One allowed computer_run_command returned KEY_ENCRYPTION_KEY,
the session-signing secret and the database password, none of it on the audit trail. The API and its
migrations now run as their own account, so the kernel refuses that read; the browser is handed only
the variables it needs, so its own environment carries none of those keys; and the files under
/run/s6/container_environment are closed to the shell. A deployment that runs each Bot in its own
sandboxed computer, as the documentation asks for, was never exposed to this.
0.0.11
The LlamaIndex Bot answers with the model the setup screen chose
The LlamaIndex Bot built an OpenAI client from BOT_MODEL and ignored BOT_PROVIDER, so it only
worked with an OpenAI model name sent to OpenAI. Picked with an Anthropic key, every run failed with
Unknown model 'claude-sonnet-4-5'; picked with an OpenAI-compatible endpoint, every run failed
with Unknown model for that endpoint's model, and an OpenAI model name went to api.openai.com
instead of the address given, because the client read OPENAI_API_BASE and not the
OPENAI_BASE_URL Compose passes. It now reaches the model through LiteLLM as provider/model, the
way the Agno Bot does, so all three choices answer. A model LiteLLM does not know is treated as able
to call tools, which the AG-UI workflow requires, and parameters a model does not accept, such as
the temperature LlamaIndex sends to a reasoning model, are dropped rather than refused.
The Audit page says "not enforced" only under a dry-run refusal that went ahead
On a deployment in dry-run, the Audit page printed "dry-run: recorded, not enforced" under every
allowed action, because an allowed action is always carried out, and under a tool call content
inspection had refused, because that row copied carriedOut: true from the policy step before the
call was stopped. The line now appears only on a row the policy refused and dry-run let through,
which is the one case it describes. A tool call refused for carrying credential material is now
recorded with carriedOut: false in every mode. Rows already written keep their old value, and the
page reads them correctly either way.
The Routines page says when nothing is there to run them
A routine needs a second process to fire it, and a deployment that never started one looked exactly like a deployment that had: the routine was stored, its schedule was computed, and the page showed it waiting with a next run time, right up until nobody's standup notes arrived. Every sweep now records that it happened, and the page reads that record. Somebody with standing routines and nothing sweeping is told so — that no worker has ever checked in, or when the last one did — instead of being shown a page that looks correct. The window is the fifteen minutes a routine's own schedule already has as its floor, so a gap longer than that is one no routine could have wanted.
A long tool result or relayed answer is cut between characters, not through an emoji
A tool result over 20,000 characters, and a Bot's answer over 12,000 relayed back through a handoff,
were cut by UTF-16 code unit. When the cut landed inside an emoji or any other character outside the
Basic Multilingual Plane, the text handed to the model ended on half of it: a lone surrogate that
JSON carries as a bare \ud83d and UTF-8 turns into a replacement character. The cut now stops one
unit short in that case, the way an attached text file's already did. Anything that fits is
untouched, and the note saying the result was cut reads as before.
A boundary rule can ask what started a run, not only whose authority it carries
A routine's turn goes through exactly the path a person's chat turn does, as the routine's owner:
their grants, their connections, their thread. That is the right design, and it is also why
actor.id cannot tell a scheduled run at three in the morning from the same person typing. The
trail already drew that distinction — AuditInitiator is signed into the run assertion and written
onto the row, so an investigator can see a routine caused something. A rule could not ask the same
question.
The policy context now carries initiator, with the kind and id the trail already records, so this
is writable:
deny: initiator.kind == "routine" && intent == "run_command"
A deployment happy for a Bot to run a shell while somebody watches, and not happy for it to do so
unattended, can now say so. The id is there too, so a single routine can be named rather than
scheduled runs as a class. handoff is its own kind, for a Bot that hands work to another Bot.
Nothing is refused that was not refused before. The field is neutral — {kind: "person", id: ""}
— everywhere a person is driving, which is every path that does not carry an initiator today,
including every action on a Bot's computer: those are driven by the browser, so they really are
somebody's session. It is required rather than optional for the reason #115 exists: cel-js throws on
an unbound identifier and a throw fails closed, so a field that were sometimes absent would turn one
rule about routines into a deployment that refused every ordinary click.
Replaying a rule against history reads the initiator off the row when it is there and treats a row that predates the field, or carries a shape this version does not recognise, as a person.
The Python LangGraph Bot tells its model why the deployment refused a tool call
When the deployment would not run a tool call from the Python LangGraph Bot — a token it no longer
accepts, one issued to another Bot, or a malformed call — it answered with the status and a reason
under error, and the Bot told its model only "Refused. Tool callback returned HTTP 403." The model
could say a call was refused but not why, and could not correct a call the deployment had named as
malformed. The reason now follows the status, the way the TypeScript LangGraph Bot already passes it
on. A refusal with no readable reason reads exactly as before.
A tool argument that starts with "Basic" or "Bearer" is no longer refused as a credential
Content inspection read any MCP tool argument whose first word was "basic" or "bearer", in any case,
as an authorization header. A Bot searching Drive for "Basic onboarding checklist", or posting
"Bearer of bad news" to a channel, was refused because its arguments "contain credential material".
Those words are now refused only when what follows them is shaped like a credential: base64 that
decodes to user:password after Basic, and a token of at least 16 characters with a digit,
punctuation or mixed case after Bearer. A shorter bearer token, or a Basic value that does not
decode to user:password, is no longer caught by this pattern; the same value under an
authorization field is still refused by name.
0.0.10
The LangGraph Bot says a refused tool call was refused, not that it found nothing
When the deployment would not run a tool call from the LangGraph Bot — a token it no longer accepts, or one issued to another Bot — it answered 401 or 403 with a reason and no result, and the Bot told its model "The tool returned nothing." The model then told the person nothing was found. The Bot now tells its model the call was refused, with the status and the deployment's reason, the way the Python LangGraph Bot already does, and the transcript draws it as a refusal. A tool that answered is passed on exactly as before.
Revoking a grant with a blank ref or Bot is refused instead of reported as done
DELETE /api/plugins/grants checked its query params with truthiness, and a query param is
always a string: ?ref=%20%20 is truthy, so it skipped the 400, deleted zero rows by exact
match, still wrote a plugin_revoked audit row naming whitespace, and answered ok:true. The
POST twin already required trimmed non-empty strings. DELETE requires the same now and acts
on the trimmed values, so a blank ref or Bot is a 400 with the same message, no delete, and no
audit row.
The Bot in the box and the LangGraph Bot read a message that has a file attached
A message with a file attached reached both Bots as [object Object],[object Object], in place of
what the person typed and the file both: they read a message as a string, and one carrying a file is
a list of parts. Each part now reaches the model as what it is — the words, the text of an attached
file, an attached image — and a part neither can read is named rather than dropped.
A fractional or out-of-range computer setting takes the fallback instead of breaking the boot
numberFromEnv accepted anything Number called finite and positive, so PORT=80.5 bound
nothing usable, PORT=99999 misbound at boot, a fractional timeout fired before any action could
finish, and COMPUTER_MAX_BROWSERS=2.5 reached eviction math as a fraction — each reading as a
broken computer rather than a mistaken variable. Every reader is a port, a timeout, or a count,
so only whole numbers on sight are values now and anything else takes the documented fallback;
the port additionally keeps its 1–65535 range, the way the supervisor's own port parser already
does. Zero semantics are unchanged: COMPUTER_BROWSER_IDLE_MS=0 still keeps browsers resident.
A malformed page size is refused instead of silently coerced
GET /channels and GET /api/admin/people read ?limit= with Number.parseInt, which
coerces: ?limit=12abc arrived as 12, ?limit=3.9 as 3, and each answered 200 with a silently
wrong page. Both now share one strict parser with the audit list's rule: absent or blank leaves
the store default alone, a run of digits is clamped into range against the same ceiling the store
enforces, and anything else is a 400 naming the parameter, before the database is reached.
A skill written with a non-string slug or summary is refused instead of failing the insert
POST /api/plugins/skills checked presence with truthiness and then ran the slug regex, which
coerces: {"slug":123} tested the string "123" and passed validation, and {"summary":{}} had
no check at all. Both reached the store, where the insert threw an uncaught error — a 500 for a
caller error. A slug, a title and instructions must be non-empty strings now, the slug pattern is
tested only after that, and a summary must be absent or a string; anything else is a 400 naming
the field, before any refusal check, store write, or audit row.
More endpoints refuse a malformed request instead of coercing it or failing open
The same treatment reached the rest of the write and query surface: the agent tool-call endpoint's name and arguments, the policy dry-run and audit-event list limits, a component's publication flag, the sandboxed-component fields, and a catalogue entry are each checked and answered with a 400 that names the bad field before the store is touched. The four hand-driven computer gestures — click, type, key and scroll — validate their own payloads the same way, so a click with no coordinates or a key with no key is refused rather than sent to the computer as a no-op.
One of these closed a hole rather than tightening an edge. A component's list of decision functions
was filtered to the strings in it, so {"functions":[123,null,{}]} became an empty list, the
permission check ran over nothing, and the answer came back allowed for functions the caller had in
fact named. The verdict is about the functions named now, or a 400; an absent list still means none.
Generated interfaces, tables and forms
Generative UI is enabled by default; set OPENBOT_GENERATIVE_UI=false or 0 to disable it.
Bots can render A2UI interfaces, compare records in sortable tables, and collect related answers in
a form that waits for submission. LangGraph receives the component schemas needed to draw these
interfaces correctly.
The playground rejects invalid JSON before saving or publishing, confirms successful saves, and shows published custom components in the administrator's gallery.
A Bot's computer is rebuilt when it holds a token the deployment has stopped using
A computer checks every caller against the COMPUTER_TOKEN it was created with, and holds that one
for the life of the container. The shell mints the generated secrets once per deployment and does
not rotate them, precisely because a computer outlives a restart, so ordinarily there is nothing
here to go wrong. Setting a machine up again from nothing is the occasion where the token really
does change: the credential store is emptied, a new one is minted, compose rebuilds everything it
owns with it, and the computers, which the supervisor makes rather than compose, survive holding the
old one.
Everything then refuses, and nothing says why. The gateway allows the action and the trail records it as carried out, the computer answers 401, and the screen says "Not authorised" while naming no token and no container. Measured on a first run of v0.0.9 against a computer made by the install before it, five days earlier: every page the Bot tried to open, and the live screen beside it, failed that way.
The supervisor now replaces a computer whose token is not the one it is handing out, the same way it already replaces one built from an older image, keeping the profile and workspace volumes so the Bot comes back with its logins and its files. A deployment that sets no token is left alone, because a computer with no door on it is a choice the environment made rather than a mismatch to act on.
0.0.9
The People screen keeps a person's last sign-in when their sessions go away
Last signed in was max(sessions.created_at), so it disappeared whenever the session rows behind
it did: on sign-out, on expiry, and when an administrator removed somebody. Restoring them did not
bring it back, and the person moved to the bottom of the list as somebody who had never signed in.
The moment of each sign-in is now recorded on the person, so the answer survives all three, and a
removed person's row shows when they were last here instead of leaving it out. Existing deployments
are backfilled from whatever sessions they still hold.
A message can carry files
Pick them, drag them onto the composer or paste them in: up to eight files on one message, images up to 8 MiB and text files up to 1 MiB, in the four image formats a model reads (PNG, JPEG, GIF, WebP) and four text ones (plain text, Markdown, CSV and JSON). A file is uploaded as it is staged rather than when the message is sent, so the send is immediate and a send that fails keeps what was attached to it, instead of asking somebody to find eight files again. The bytes live in the deployment's own database and are served back from the app's own origin, which is also why the type is decided by reading the file rather than by believing what the browser called it: something that claims to be text and is not UTF-8 is refused rather than stored and served as accepted text on the client's word.
What reaches the model is bounded separately from what may be uploaded, because the two limits pay for different things. An image goes whole. A text file is read up to 120,000 characters, roughly 30,000 tokens, which is one attachment's share of a window that also holds the conversation and up to seven other files, and the part sent says where it was cut so the model is not left answering about a file it read only part of. A megabyte of text is therefore stored whole and read as its first eighth or so, and the person who attached it is not yet told that.
Unsent attachments have to be swept, or somebody who stages 32 can attach nothing again
A file is stored when it is picked, not when it is sent, so every abandoned draft leaves bytes
behind and nothing in the image reclaims them. The Helm chart runs the sweep hourly and deletes
unsent files older than a day. Any other deployment has to run it:
bun scripts/cull-staged-attachments.ts from /app/server, one pass then exit, with the retention
window as its one optional argument. Unlike the routines sweep beside it, it needs only
DATABASE_URL, so an external cron can run it with one variable set.
This is not only about growth. A person may hold 32 unsent files across all their channels, which is what bounds a client that ignores the eight-per-message cap, and the refusal on the 33rd tells them anything still unsent is cleared within a day. That sentence is a promise made on the sweep's behalf: where nothing runs it, the files are never cleared and anybody who reaches 32 can attach nothing, in any channel, from then on. At 8 MiB a file, 32 staged files per person is the 256 MiB to size storage against.
Fresh desktop installs pin the latest published deployment
The desktop app resolves GitHub's latest published release on first setup and downloads that exact tag's source and image manifest. It records the version after both downloads finish and reuses it on subsequent starts, so new installs no longer stay tied to the app's old v0.0.8 default.
The Bot computer refuses a malformed scroll or live input before the browser sees it
A non-finite wheel delta travelled into Playwright and came back as a 502 that read as a broken
computer, and any JSON object on the live-screen socket fell through to Input.insertText or
forwarded wrong-typed coordinates to CDP. Scroll deltas must be finite numbers now, and live
input must match its mouse, wheel, key, or text shape; anything else is a 400 naming the field.
A non-string plugin grant or tool call is refused before it reaches the store
POST /api/plugins/grants and POST /api/plugins/call checked presence, not shape, so a JSON
number, object, or whitespace string passed and failed inside the store as a 500. Refs and Bot
ids must be non-empty strings now, and anything else is a 400 naming what is required.
A fractional or infinite snapshot id is refused as malformed, not stale
A snapshotId of 1.5 or Infinity passed the acting routes and never matched the stored
integer, so the answer was a 409 stale snapshot and the caller retried a request that was
malformed. Non-integer ids are refused with a 400 naming the ref and its snapshot before any
decision or audit row.
A DATABASE_URL with a port of zero is refused at start-up
postgres://…:0/… parsed and booted, and every query then failed against a port nothing listens
on. Ports outside 1-65535 are refused with a sentence naming DATABASE_URL before a socket is
ever opened.
Setup installs the container engine, instead of telling somebody to go and get one
Setup ended at "Install Podman Desktop or Docker Desktop first" on any machine that had neither, which is every machine this app is for: the step existed with nothing behind it, so the whole install stopped at a download page. It installs one now, and a Compose with it, because Podman ships no Compose implementation and a machine with a freshly installed Podman still cannot raise the stack. Both are pinned to the digest of the release they were tested against and refused if it does not match, because these are files this app then executes. Only what is missing is added: an engine somebody already has is theirs, and a Compose that already answers is left alone. Windows installs unattended; macOS and Linux each raise the platform's own authorization prompt, which is not something to route around. The two plan sign-ins set the engine up as well, since they run in a container themselves and previously named an obstacle with no way past it. Every engine command names a resolved path rather than trusting the PATH this process was started with, so an engine installed a minute ago can be used by the run that installed it.
Setup ends with a question the Bot has to answer
Every step before the last one proves that something started, which is not the same as proving the answers work. A refused key, a lapsed plan or a model the account cannot use each give a stack that comes up clean and a Bot that cannot answer, and handing over at that point means somebody finds out later, inside the product, with no idea which of their answers caused it. Setup now ends on a question with one checkable answer and waits for it. A run that produces no text is a failure here rather than an empty answer, because the framework catches its own 401 and logs it, leaving the whole of a refusal in the container's log and nowhere else. The sentence on screen is OpenBot's own and names the choice to change, with the harness's log behind a disclosure for the developer half.
A subscription picks the Bot that can spend it
A plan is not a key, and only one Bot speaks each vendor's subscription. Signing in to a Claude plan
and keeping the default Bot gave a stack that came up clean and a Bot whose log read "Missing
credentials. Please pass an api_key", after two screens the person had answered correctly and with
no way to know which answer to change. A plan now re-points the Bot, and the model screen says which
Bot that will be while there is still a screen to say it on. A signed-in ChatGPT plan gets the Codex
model, because a plan token is a bearer for one address that langchain-openai pins on purpose and
cannot be reached by pointing OPENAI_BASE_URL at it. The vendor's own token store is kept beside
the .env as an owner-only file and mounted into the harness, so the renewals the provider makes
outlast the container: the access token on its own expires within the hour and nothing can renew it,
which would give a Bot that works in the morning and fails after lunch. The window also has an Edit
menu now, so the shortcut works on the screen whose own instruction is "paste the code it shows you";
macOS routes the clipboard through the menu bar, and a window without one has no Paste.
Signing in to CopilotKit from the window works
The sign-in that creates a key for somebody had never been run end to end, and it failed four times
in a row, each time silently or with a message that named nothing. The session is called cliToken,
not token, so the first exchange failed with "error decoding response body" and no way to tell
which field or which endpoint; a failure carries the response now, masked, because the one that
diagnosed this also carried a live session token. Project ids are numbers, and requiring a string
dropped every project, so the screen told somebody with ten of them that the account had none: an
empty list and an unreadable one are told apart now, because one of them is a lie a person cannot
argue with. The keys endpoint declares project_id as a number with no coercion, so the string "7"
came back as a validation error on the last step of the flow. And the project tiles drew as blank
white rectangles, because the tile rule overrode the background to white and not the colour, asking
somebody to choose between six empty boxes. The sign-in address is kept on screen the way the plan
sign-ins keep theirs, for the machine whose browser is not the one in front of the person.
An endpoint that needs no key can be connected
The compatible row names Ollama and vLLM in its own summary and then refused to continue without an
API key. Neither has one, so the two examples the screen offers by name were the two it would not
accept, and the way out was to invent a key and hope the endpoint ignored it. An address and a model
name are what that row needs. Both bundled Bots refused to start without OPENAI_API_KEY as well, so
fixing the screen alone would have given two dead containers complaining about a key that person's
server does not have: a base URL is a model and its key belongs to it, so a key is now required only
when nothing else names the endpoint, and plain OpenAI still refuses without one. Because a
deployment pulls the image the release pinned, and an image published before the Bots learned this
still refuses, a placeholder string is sent to an endpoint that reads no key. Ollama, vLLM, LM Studio
and llama.cpp all ignore the value. It is written in plain sight rather than put in the machine's
credential store, because it is not a credential, and a key somebody actually typed is used
unchanged. The model name reaches the bundled Bot too, which reads AGENT_BOT_MODEL and had been
left on a pin chosen for OpenAI's own catalogue.
A model name no longer outlives the answer that chose it
The compatible row is the only one that names a model, and switching away from it kept the name.
Answering with an OpenAI key after trying a local endpoint left BOT_MODEL=local-model, so the Bot
asked OpenAI for a model only that person's own server has, and the last screen said "That account
cannot use the model that was chosen" about a model this run never chose. The name is removed rather
than emptied, so the compose default applies, and taken out of the file as well, because the writer
keeps the lines it did not write and that is what let it survive.
Credentials go to the machine's own credential store, not the .env
The .env is a settings file, and a settings file is something somebody opens, reads out to support
or pastes into a chat. A model key, a plan token and the tokens these services prove themselves to
each other with are not settings. They go to the login Keychain on macOS, to DPAPI on Windows
encrypted to the signed-in user, and on Linux to an owner-only file, which is said out loud rather
than dressed up: no desktop Linux install can be assumed to be running a Secret Service daemon, and
refusing to save a credential because gnome-keyring is missing would fail more people than it
protects. The value never goes on a command line on any of them, since ps is readable by every
process the person runs. macOS goes through the Keychain itself rather than the security command,
whose password prompt truncates at 128 bytes with no error and an exit status of zero: an OpenAI
project key is 164 characters, so every one of them was stored cut short and read back cut short on
the next run, while the run that saved it worked fine. From the store the credentials reach the
containers and the host processes as environment, which compose resolves before it reads the .env,
so a secret arrives at exactly the services that declare it and is written down nowhere. What an
earlier version already wrote in plaintext is moved and then purged, or the change would have bought
nothing for anybody who already had OpenBot.
The credential store is asked once per run, not once per screen
Four Keychain dialogs every time the setup screen mounted, each needing a click before the window would go on, and four more for navigating between setup and OpenBot. macOS authorizes every individual read of a stored password unless the application is signed with an identity the item's ACL already trusts; a development build is re-signed on every compile, so its ACL never matches, and the wizard reads four secrets to arrive filled in. The store is asked once per name per process now and the answer is held in memory, absence included, or a machine with nothing stored is asked on every mount for something that was never there. Writes go through the same memory and forgetting clears it, so the two cannot disagree. This does not remove the prompts on a first run, and nothing in this process can: that decision belongs to the operating system and to the signature.
Stop stops the Bot that was picked, and the next Start no longer refuses because of it
Compose only acts on a profiled service when the profile is named, so Stop left the one container the person actually chose running on their laptop after they had stopped the app, still holding its port. The next Start then refused, saying something was already listening on 4206, about a container OpenBot itself had started, which the person never saw and could not find, and there was no way forward from that screen. A port this deployment already publishes is not a stranger on the port, so the check reclaims our own and keeps its teeth for somebody else's.
Stop stops the host processes on Windows
Measured on Windows Server 2022: Stop took the containers down, reported success, and left the server
answering on 3001, the routines worker up, and both halves of the app answering on 3010. Only the
containers had gone. The handles a window holds cover what that window started and die with it, so a
window stopping a stack an earlier one started held nothing, and the Windows arm returned success
with a comment saying the host processes end with the session. They do not. The pids are written
beside the logs when the processes start and Stop reads them, ending each process together with its
children, since bun run serve starts the real server as a grandchild. A sweep of the ports this
deployment publishes stays as a second pass for a stack whose pid file is gone. Separately, a
byte-order mark in front of package.json, which Set-Content -Encoding UTF8 writes freely, made
the manifest unreadable and was reported as "the deployment is older than this version of OpenBot",
sending somebody looking for a newer installer over three bytes.
The installed app is served without a development server
"Show OpenBot" did nothing on a machine where the stack was up. The window said OpenBot was running,
the button was there, and clicking it had no effect at all. The app host process was dead: it was
started through vite preview under bun --bun, and Vite's proxy calls socket.destroySoon() when
an upstream response ends, which bun's sockets do not implement, so the process died with a TypeError
on the first call the app made. It served its page, exited, and nothing listened on 3010 from then
on, while the shell went on reporting a stack that was up, because the containers were. The app is
served by a small server of its own now: a directory and one forwarded prefix, which is all an
install needs, with no Node and no Vite at runtime. The websocket upgrade the live screen needs is
forwarded rather than answered with HTML, a miss under /assets is a 404 rather than the page, and
paths are confined to the directory, since the deployment's .env sits two levels above it. The
button also shows what it was told: the call behind it already answered "OpenBot is not answering on
port 3010 yet, so there is nothing to show", and the click handler threw that sentence away, which is
why a dead process looked like a dead button.
A conversation whose history this deployment cannot reach says so
Clicking a conversation in the rail drew the coworker's name and then nothing at all. The rail comes
from OpenBot's own database, so a channel is listed whatever the history store says, while the
messages live in the Intelligence project: pointing a deployment at a different project leaves the
platform answering THREAD_NOT_FOUND. That 404 is deliberately read as "no history" and has to stay
that way, because a thread id is minted before the thread exists, so a brand-new conversation 404s as
its normal opening move, and widening it would tell somebody their conversation was gone and invite
them to start it over. The two are told apart by lastMessageAt, which is set only once something
has been said: a conversation with none is genuinely new and silence is correct, while one that has
been spoken in and comes back empty has a history this deployment cannot reach. That one now says so,
in the notice slot beside the existing explanations for a deleted coworker and for turns that could
not be parsed.
bun run dev no longer starts a routines worker that cannot start
bun run dev fanned out across every workspace, and one of them is the routines worker. That worker
is handed DATABASE_URL, SERVER_INTERNAL_URL and WORKER_SHARED_SECRET by scripts/start.sh and
by nothing else, so the copy this command started read none of them and threw at boot on every run,
printing a stack trace in between the app's output and the server's. It has never started
successfully. The command now starts the app and the server, which is what README.md and
docs/development.md already say it does. Routines are unaffected: scripts/start.sh starts the
worker exactly as before, and on Kubernetes the CronJob does.
Double-clicking works while a person is driving a Bot's browser
A double click was sent to the Bot's browser as two separate first clicks, because every press said
it was the first one. Chrome fires dblclick on the page only when the second press says it is the
second, so the page never saw one at all and event.detail was always 1. Opening a row in a table,
expanding a node in a tree and double-clicking a word to select it were all things a person holding
the wheel simply could not do, with nothing on screen to say why — the clicks landed, they just each
counted as the first. The count the person's own browser worked out is now the one that is sent, so a
double click is a double click and a single one is unchanged.
Pressing Enter works while a person is driving a Bot's browser
Taking the wheel of a Bot's browser is mostly for the sign-in it cannot do itself, and Enter is how a sign-in ends. Every keystroke reached the page, and Enter reached it as a key press that produces no character — which Chrome delivers to the page's own listeners and then does nothing further with. So the form did not submit, a new line in a text box did not start, and a button somebody had tabbed to was not pressed, while anything on the page listening for the key saw it arrive. There was nothing on screen to explain it: the keystroke was not refused, it simply had no effect, and the way out was to click the submit button instead. Enter now carries the carriage return a keyboard sends, which is what makes Chrome carry out what the key means. Measured against Chromium 151: every other editing key — Backspace, Delete, Tab, Home, End and the arrows — already did what it meant and is unchanged, and a single-line field still holds exactly what was typed into it.
A half-ticked box is no longer described to a Bot as ticked
The snapshot a Bot reads before it acts on a page says whether each box is ticked, and Playwright
writes that as [checked] for one that is and [checked=mixed] for one that is neither — which is
what the "select all" above a partly-ticked list carries. The parser treated any value other than
the string false as ticked, and mixed is one, so a half-ticked box was reported as done. A Bot
asked to select everything read it as already selected, clicked nothing, and said the rows were
chosen when most of them were not. mixed is now reported as not ticked, which is both the true
half of a yes-or-no answer and the one that gets the right action: clicking a half-ticked box ticks
it. An ordinary tick and an ordinary empty box are unchanged.
A Bot cannot end its turn by asking a person nothing
ask_person is how a Bot stops and puts something to a person instead of guessing, and a call with
no question in it was already meant to come back as a sentence telling it to say what it needs. That
only happened when the field was missing altogether. A question that was present and empty was
carried out: the Bot was told its question had been put to somebody, its turn ended there, and the
trail took an escalation row with nothing in its question — the row an administrator counts these by,
saying a person was asked something that was never said. On a deployment whose escalation route is a
duty desk rather than the person already in the conversation, it is a page to somebody with no
question on it. A blank question is now refused with the sentence that was already written for it,
and a question typed with room around it is recorded as the question rather than as the spacing.
A routine scheduled for Sunday says Sundays, whichever number it was written with
Crontab has always let Sunday be either 0 or 7, the scheduler here takes both, and a routine written
with 7 is stored and fires on Sunday like any other. Only the 0 spelling was recognised by the
sentence the Routines page draws and the Bot reads back, so a working weekend routine appeared on
that page as 0 9 * * 7 while its neighbour said "Sundays at 09:00" — the same schedule, described
two ways, with the raw one looking like something had gone wrong. Both spellings now read as Sunday,
and a list that names the day under both of its numbers says it once.
A tenant package's theme may carry a comment
A package's theme.css is checked at start-up against what it is allowed to define: the :root and
.dark blocks, the approved variables, no imports and no URLs. A CSS comment defines none of those
and was being read as though it did. One above the blocks — the line a hand-written stylesheet opens
with, saying whose brand it is and where the colours came from — was left over once the blocks were
set aside and refused as a second selector; one inside a block was split on the semicolons around it
and refused as a variable name, with the comment quoted back as the name it was not. Because the
package is read while the deployment starts, that was not a warning: the deployment did not come up,
over a comment, saying nothing about comments. Comments are now taken out before the file is read as
definitions, which also closes a comment wedged into the middle of url( as a way past the rule
above it.
Test connection stops reading once it has seen the agent answer
The button that checks an agent before it is registered sends it a real run and reads what comes
back, needing only the opening of the stream to tell an AG-UI agent from a web server that happens to
be reachable. It was reading the whole reply first and applying that limit afterwards, so the check
took as long as the agent's run did. An agent that streams for more than fifteen seconds — a Bot
working through a document, a model answering slowly — was given up on mid-answer and reported as
The agent started answering and the connection broke, about a connection that had not broken and an
agent that had answered correctly in its first two events. It now reads the opening it needs, closes
the connection, and answers in the time the agent took to start rather than the time it took to
finish.
A key pasted with a line break in it is now refused, instead of reported as an unreachable agent
The box that holds an agent's key takes whatever is pasted into it, and what comes off a clipboard is not always what was on the screen: a long key copied out of a wrapped terminal line brings the wrap with it, and a hyphen copied out of a document has often been turned into an en dash on the way. Neither can be sent as an HTTP header — the runtime refuses the value outright — and neither was being looked at. On Test connection that refusal surfaced as "This server could not reach that address", with a suggestion about tunnels and firewalls, about an agent that was running perfectly well and had never been dialled. Stored on the Bot it was quieter and worse: the form said saved, and every turn that Bot took afterwards failed on a value nothing on screen said anything about. Both places now check the value before accepting it and say which kind of character is in the way. The character is named; the key never is.
A deployment directory pasted with a stray space goes where it says
The desktop setup screen asks where OpenBot should live, enables Start once that box is not blank after trimming, and then sent the untrimmed string — the same trap the API URL, the gateway URL, the intelligence key and the model key were taken out of, and this is the one of the five that is a place on disk rather than a credential. A path copied with the space the selection picked up, or with the newline a copied line carries, was used whole. A trailing space made a second directory beside the one everything else means: the tray's Stop and the next launch both ask for the default path, which has no space in it, so a person was left with a deployment nothing on screen could reach. A leading space was worse, because a path starting with a space does not start with a separator — it stopped being absolute, and the deployment was laid out relative to wherever the window happened to be running from. The path is trimmed at both ends now. Spaces inside it are part of a directory's name and are left alone.
The desktop app notices a busy port whichever loopback holds it
The shell refuses to start when something already holds port 3001 or 3010, because otherwise the
readiness check that follows is answered by a server it never started: everything reads green and
none of it is yours. That readiness check asks both loopback addresses on purpose, since a process
binds whichever one its runtime resolved localhost to — Node picks ::1, Bun picks 127.0.0.1 —
so an answer at either counts. The refusal in front of it asked only 127.0.0.1, which meant a port
held on ::1 alone was reported free and the start went ahead into it. Both addresses are asked
now, so the two agree on what "in use" means and the person is told which port is taken and what
OpenBot wanted it for.
A request for a secret no longer follows a Bot into tomorrow's conversations
An unanswered ask to take the wheel stops being shown after ten minutes, because control belongs to a Bot's computer rather than to a conversation. The other prompt on that computer, the masked box a Bot opens when it needs one value it must not be told, was never given the same treatment: it sat there indefinitely, so every later conversation with that Bot was flagged as needing a person and showed a request for a password, captioned with a label written for whoever asked half a day earlier. It now expires on the same ten-minute window, and stops being answerable at the moment it stops being shown, so a value typed into a box left open in an old tab is refused rather than sent to a page whose run has ended. A request inside the window is unchanged, and a person actually holding the wheel is still never timed out.
COMPUTER_BROWSER_IDLE_MS=0 now keeps browsers resident, as it says it does
Zero is the documented way to switch off the sweep that closes a Bot's browser after it has sat untouched, and the sweep itself reads a timeout of zero as being switched off. The value never got that far. It was read the way the cap on running browsers is, where zero would close every browser the moment it opened and so has to be refused, and an operator who typed zero got the thirty-minute default handed back instead. Their browsers went on being closed, which is a Bot signed out of a site that only issues session cookies and a cold Chromium on its next turn. Zero is now kept for this one setting. A blank variable, which is what an unset variable declared in a compose file arrives as, is still not zero: it means "not set" and takes the default, as do a negative and anything that is not a number.
A flag or a family emoji in a channel preview is no longer cut in half
The one line a roster draws is cut to a cap, and the cut walked code points -- right for a plain emoji, wrong for every emoji built out of more than one. A flag is two regional indicators, a family is three people joined by zero-width joiners, a thumbs-up with a skin tone is the thumb plus a modifier, and a keycap is a digit plus a variation selector plus an enclosing mark. Landing the cut inside any of those left a boxed letter, a dangling joiner or a bare digit in the sidebar, in the generated channel title, and in the excerpt the titler is shown. The cut is now taken between grapheme clusters, so what a person sees as one character is kept or dropped whole. Plain text is cut in exactly the same place as before.
A scroll with an unusable deltaY is refused, rather than scrolling some other distance
POST /computers/:botId/scroll and POST /computers/:botId/human/scroll accepted any JSON number
as deltaY, and 1e999 is a JSON number: it parses to Infinity, passes the typeof check, and is
turned back into null by the hop to the Bot's computer, which reads the field as absent and scrolls
its own default distance. The caller was answered 200 for a scroll it had not asked for. A deltaY
that is not a finite number now answers 400 and the page is not touched, the way the timeout on
exec and the coordinates behind a person's click already did.
An MCP call carrying x-api-key is stopped the same as one carrying api-key
The check that keeps credentials out of MCP tool arguments compared each argument name against a
list, and api-key was on it while x-api-key was not -- so the spelling that is more obviously a
credential header was the one that went out. x- is the conventional prefix for a non-standard
header and says nothing about the value, so it is now dropped before the comparison. The same pass
adds the spellings of names already on the list that were missing from it: passwd and pwd for
password, auth_token and bearer_token and session_token for token, api_secret and
secret_key and signing_key for secret, and ssh_key for private_key. Nothing new counts as
a credential: an argument named x_axis, token_count, max_tokens or secretary is passed as
before.
One command to stop what start.sh started
Stopping the local stack meant four commands read off the end of a successful start, and the one
easiest to miss was the one that mattered: a Bot's computer is made by the supervisor rather than by
compose, so docker compose down left a Chromium running per Bot. bash scripts/stop.sh stops the
app, the routine worker, the API server, the compose services and every Bot computer, in that order,
and is safe to rerun. It kills a port holder only once that process has identified itself as
OpenBot, so an unrelated process on 3010 is named and left alone rather than killed. Nothing is
deleted: the database, the Bots' files and their browser profiles are volumes. --keep-computers
leaves the browsers signed in.
The trail says when an identity provider was added, not only when one was taken away
Whoever holds an identity provider decides who can sign in at all, and the audit trail recorded only half of that. Removing one through the administration screen was written down; registering one was not, because registration is the sign-in library's own endpoint and nothing this deployment owns ran on the way through. The event type for it had been declared and never written. Removing a provider through the library's endpoint rather than the screen was unrecorded for the same reason. Both are now written where the deployment already stands in front of those routes to check that the person asking is an administrator, so a provider appearing or disappearing names itself and whoever did it.
Two workers on one machine can no longer fire the same routine twice
Every process that claims work from the shared queue named itself after its hostname, and the queue
tells two claimants apart by that name alone. Two processes on one machine therefore had the same
name, so the lease meant nothing between them: one whose lease had lapsed was still told the item was
its own, and both went on to dispatch it. A routine fired that way opens two runs and sends the same
scheduled message twice. Nothing stops two workers running on one machine — the worker binds no port,
and scripts/start.sh looks for a process it does not start the way bun run dev does. The name now
always carries a random suffix, so a second process is a different claimant. It also keeps the
hostname, so a stuck claim still traces back to the machine holding it, and a blank HOSTNAME is no
longer read as a name — which had made every replica in a deployment share one.
The desktop app writes its .env readable only by its owner
The desktop .env holds KEY_ENCRYPTION_KEY and every minted token, and those are now long-lived:
the first start writes them and every later start reads them back. It was created at the default
umask (0644), so on a shared macOS or Linux machine another local user could read the vault key off
disk. The file is now narrowed to 0600 after it is written. Windows has no equivalent mode and its
single-user desktop profile is already the boundary, so the change is Unix-only.
The desktop app stops adding a banner to .env on every start
env::write keeps the lines it did not write, and its own header comment is one of them, so each
start preserved the previous banner and appended another. A deployment started fifty times had fifty
copies of "Written by OpenBot Desktop" and fifty blank lines stacked above its settings. The banner
is now recognised and replaced rather than kept, and comments somebody else put in the file are left
alone exactly as before.
Starting the desktop app again keeps the secrets the first start generated
The shell generated a fresh set of secrets every time Start was pressed, including the
KEY_ENCRYPTION_KEY that encrypts the credential vault. The database survives a stop, so the second
session of an installed OpenBot met a vault it could no longer read: every stored credential failed
to decrypt, with an error that named an operation rather than a cause. It also handed the server a
COMPUTER_TOKEN that no computer created before the restart holds. The secrets an existing .env
already carries are now kept, and only generated when there is nothing usable to keep — a value
published in this repository does not count, and neither does a KEY_ENCRYPTION_KEY the server would
refuse to start on.
The desktop app refuses a deployment download that writes outside its own directory
The shell fetches the release tarball and lays it out under the directory it manages. The check that
kept an entry inside that directory compared paths lexically -- root.join(path).starts_with(root)
-- and Path::starts_with matches components without resolving .., so app/../../elsewhere
started with the root and still landed outside it. An entry has to begin with a directory a
deployment wants, which app does, so the file filter did not stop it either. Every component of a
path inside the tree is now required to be an ordinary name, and the traversal is refused by name.
A credential pasted with a stray space into the desktop setup screen now works
The setup screen enables its button on value.trim() !== "" and then sends the untrimmed string, so
a key copied from a provider's dashboard with the space the selection picked up arrived intact. The
model key was trimmed on the way into .env; the API URL, the gateway URL and the intelligence key
entered on the same screen were not, so Compose passed the space through, the provider rejected the
credential, and the failure the person saw named neither the space nor the field. All four are now
trimmed the same way.
Example LangGraph and Mastra Bots no longer bind an ephemeral port on empty PORT=
An empty PORT= in compose or .env used to become NaN for those two example processes, so they listened on a random port while docs still named 4300/4400. They now use the same listenPort helper as agent-bot: empty is the documented default, and a prefix typo refuses to start.
An empty app port is the default, not a random one
APP_PORT= and SERVER_PORT= in a compose file or leftover .env used to become NaN for the Vite
dev and preview servers, so the UI bound an ephemeral port while the proxy target was http://localhost:.
Both empty values now mean the documented defaults (3010 and 3001), and a non-numeric value refuses to start.
The trail says what started a run, not only whose authority it had
A routine runs as the person who set it up, and a Bot handing work to another Bot runs as the person
who began the conversation. Both are correct, that is whose grants and whose connections are being
used, and both meant an action taken while somebody slept was written into the audit trail as though
they had taken it themselves. Telling the two apart meant correlating timestamps against
routine_runs by hand, and there was nothing at all to correlate a hop against.
Every audit row now also names what caused it: a person, a routine, another Bot handing work on, or the deployment itself. It travels inside the signed run assertion, so a tool call, a hop, a Bot stopping to ask its person and a stalled stream all say it, and a Bot cannot relabel its own run. The Audit screen has a Started by column and a Nobody watching view that answers the question directly. An unattended run is the one nobody is there to notice going wrong, which is the reason it is worth being able to find.
The fourth of those exists so the column never overclaims. Two rows have no person behind them at all: the boundary and isolation rows written at start-up, and the refusal written when a caller cannot be identified at all. Those say the deployment, not a person, and they stay out of Nobody watching, which asks what ran on somebody's authority rather than what the deployment did by itself.
Nothing about existing rows changes. Every row already written, and every row a person's own click writes from now on, reads as a person, because that is what it was.
The live screen and live channel updates work again, and one request can no longer end the app
The app opened its two WebSockets against its own address, so they travelled through Vite's /api
proxy. Vite is run through bun, and under bun that proxy does not carry a WebSocket: neither the
Bot's screen nor live channel updates ever connected, and the browser retried in a loop. Worse, an
upgrade the server answered with an ordinary HTTP response — a 503 when a Bot's computer is not
running, which is exactly when somebody opens the screen — crashed the process that served the app,
taking the server and the worker with it in development. Where Vite serves the app — the dev server
and the desktop's vite preview — both sockets now address the server directly, so nothing upgrades
through the proxy and the proxy no longer offers to carry one. In production the server serves the
app itself and answers the upgrade on the same origin, so the sockets stay on the browser's own
host, which is what an ingress terminating TLS on 443 requires and a fixed server port would break.
0.0.8
A desktop shell that installs OpenBot and then becomes it
One window, on macOS, Windows and Linux. From a machine with nothing on it, one click fetches the deployment for this release, pins every image to the digest the release published, generates the secrets that are OpenBot's to generate, raises the containers, applies the migrations, installs the dependencies, starts the host processes, waits until both the API and the app answer, and then shows OpenBot in the same window. It is not a launcher for a browser tab. Stop takes the stack down, closing the window hides it to the tray, a second launch hands over the window that already exists, and quitting stops what starting started. Windows is told what it needs before anything else runs: WSL, its kernel, virtualisation and administrator rights are each named with the command that fixes them, because none of them is something OpenBot can fix on somebody's behalf.
A title or name that is only spaces is refused rather than stored
Sandboxed components, skills, custom servers and the component catalogue each accepted a title, slug or id made entirely of whitespace, and stored it. What came back was a row nobody could identify and, in the catalogue's case, entries that were empty strings. Each endpoint now refuses those the way it refuses a missing field, and the catalogue drops empty entries instead of keeping them.
A malformed socket message no longer takes the screen down
The live screen and the channel socket both assumed every payload they received was an object of the shape they expected. Anything else threw inside the handler, which in a browser means the surface stops updating with nothing on screen to say why. Both check the shape first and ignore what does not match.
The worker refuses a bad server URL when it starts, not when it first needs it
SERVER_INTERNAL_URL was read as a string and used as one. A value that was not an http or https URL
failed later, inside whichever call happened first, with an error about that call rather than about
the setting. The worker validates its environment up front now and normalises the URL, so a typo stops
it immediately and says which variable is wrong.
A sandbox template that is not valid JSON is reported as a sandbox error
A malformed template surfaced as a raw parse error from whatever tried to read it. It is a
SandboxError now, which is what the caller already handles and what the surface already knows how to
show.
A duration written in capitals is understood
durationMs accepted 30s and refused 30S. Units are read case-insensitively now.
The supervisor refuses a HostPort that is not a port
The value went through a bare parseInt, so 80abc became 80 and an out-of-range number was used as
given. Digits and range are checked, and anything else refuses to start rather than binding somewhere
nobody asked for.
The audit endpoint refuses a bad date or limit instead of guessing
An unparseable from or to, or a limit that was not a whole number, was coerced and the query ran
against whatever came out. All three are parsed strictly now and a bad one answers 400.
Chat content that does not parse is dropped rather than thrown
One malformed entry in a user message threw and took the whole message with it. The malformed part is dropped and the rest is delivered.
The example package is read by a path the host accepts
It was addressed by a URL pathname, which is not a path on Windows. It is read by a real path now.
The app can be served from a built bundle, and listens on both loopbacks
The app's only start script was dev, which runs a Vite dev server. That meant NODE_ENV=development
on a freshly installed product: the SDK drew its developer inspector over the top, with hot reloading
and source maps behind it. There is a serve script now that builds once and serves the build. Both
it and dev hand Vite to Bun directly, because node_modules/.bin/vite begins #!/usr/bin/env node
and a machine with Bun and no Node exits 127 without saying why. Vite is also told to listen on ::,
since Node resolves localhost to ::1 and Bun to 127.0.0.1, so binding one of them left whoever
asked for the other looking at nothing.
A person's Stop is recorded as a stop, not as a failed action
Pressing Stop mid-action aborts the request, and the gateway wrote that outcome beside the decision
row as a failure — the same computer.action_failed type it writes when a computer is unreachable or
times out. The row's message already said the action was stopped, but anything counting failures by
type, the natural way to watch for outages, read every Stop as one. A stop now writes its own type,
computer.action_stopped: the action did not happen and nothing broke. The audit page already groups
it with the other did-not-happen outcomes, and a policy dry-run skips it the way it skips a failure,
since both sit beside a decision row that is already scored.
A malformed DATABASE_URL is refused without printing the password
DATABASE_URL is taken apart before it reaches Bun, and the string most likely to fail that parse is
one with a stray character in the password. The refusal for an unparseable value quoted the whole
string back to name the fault, which wrote the database password into the log line that reported it.
It now names the variable and the shape it expects, the way the other refusals beside it already do,
and never echoes the value.
Wiping a computer is recorded even if clearing its stored state fails
Resetting a computer destroys the profile first and wrote the audit row last, after two Postgres deletes. A connection reset, a failover or a statement timeout in either delete threw before the row was written, so the most destructive button in the product could leave a wiped computer -- every login gone, no undo -- with nothing on the trail to say who wiped it or when. The row is now written as soon as the profile is gone, which is the point after which nothing can be put back. A failure in either delete is still reported to the caller.
Pressing Stop is recorded as a stop, not as a computer that is not running
The computer transport answered a Stop correctly only when it arrived before the request left. The
caller's signal is handed to fetch precisely so a Stop can also land mid-action, and a fetch
aborted that way rejects with an AbortError, which fell through to the message for a computer that
cannot be reached. The person was told their own click had failed because the assistant's computer
was not running, and the gateway wrote that sentence into the action's audit row as its failure --
so a deliberate stop read back as an outage. A genuinely unreachable computer and a timeout still
say what they said.
A component the server refused is no longer drawn anyway
A sandboxed component asks the server at call time whether the Bot may still use it, and a refusal
is recorded so the drawing can be replaced with a card saying so. The renderer looked that refusal
up under props.toolCall.id, which is the shape a tool HANDLER is given; a renderer's props carry
the id flat, as toolCallId. The lookup key was therefore always undefined, the refusal was never
found, and the component rendered as though it had been allowed -- so revoking a component from a
Bot did not take effect on screen until the five-second grant poll caught up, and a failed decision
request showed nothing at all.
A component whose name has a stray space is the same component
The catalogue announcement asked whether each component's name, title, kind and description
were more than whitespace, and then published the untrimmed strings. A name is a component's
identity -- it is what syncCatalogue compares against what is already published, what decide and
listForAgent look up, and what a grant names -- so a build shipping " weatherPanel " added a
second catalogue row beside weatherPanel: published, ungranted by anybody, and impossible to hold
a Bot back from under the name people use. The four fields are now stored as the strings the guard
approved.
A password with a % in it says so, instead of failing as URI error
DATABASE_URL is taken apart before it reaches Bun, and each part is percent-decoded. A part
holding a % that starts no escape -- postgres://openbot:100%pure@host:5432/openbot, which a
generated password produces often enough -- is a string new URL accepts and decodeURIComponent
rejects, so the server stopped with URIError: URI error and named neither the variable nor the
part. It now refuses with the same kind of sentence as every other malformed address: which part is
wrong, and that a literal % must be written %25.
A correctly encoded password is unaffected.
An empty Bot PORT is unset, so NaN never reaches Bun.serve
PORT= on agent-bot and agent-langgraph used to parse as NaN (?? does not treat empty as absent) and Bun.serve bound an ephemeral port while compose still published 4200/4201. A prefix typo (42o0) started on 42. Empty now means the shipped default; anything that is not a whole port number refuses to start.
The server connects to Postgres on Windows, and localhost is no longer a coin toss
Two separate faults, both of which stop a deployment reaching its own database and neither of which says so.
The connection address went to Bun as a URL. Bun reads such a URL's path, the database name, as the
path of a unix socket, ignores the host and the port, and fails to open a socket Windows does not
have (oven-sh/bun#27713). The server could not reach Postgres there at all, while psql inside the
container and a plain TCP connection from the same machine both worked, which makes it look like a
network fault rather than a parsing one. The address is now passed in parts, and DATABASE_URL is
removed from the environment as it is read, because Bun prefers that variable to the parts it was
handed and would otherwise put the address straight back through the same parser. A URL with no host
or no database is now refused by name instead of connecting somewhere nobody chose.
Separately, Compose published its loopback ports on 127.0.0.1 only. localhost resolves to ::1
and 127.0.0.1 in an order the platform decides, and a client handed ::1 first does not fall back
to the other, so the same configuration worked on one machine and failed on the next for a reason
nothing in the error mentions. Every loopback port is now published on both addresses. Both are
loopback, so nothing became reachable from another host.
A bad COMPUTER_MEMORY_BYTES refuses to start the supervisor, instead of capping a computer at 512 bytes
COMPUTER_MEMORY_BYTES=512m used to parse as 512 via parseInt, which Docker accepts as a memory
cap Chromium cannot live in. Empty COMPUTER_MEMORY_BYTES= is still unset (no cap). A value that is
not a whole number of bytes now exits before any computer is created.
An IPv6 address in AGENT_ENDPOINT_ALLOWED_HOSTS now matches however it is written
The endpoint check compares the list against the address as the URL parser spells it, compressed
and lower-case, while the list kept each IPv6 entry as the operator wrote it. [0:0:0:0:0:0:0:1]:8443
was therefore a line that silently never matched, the failure the list's other refusals exist to
prevent. Stripping the brackets on both sides also folded two different names into one, so naming
[fd00::1:8443], an address, admitted [fd00::1]:8443, another address on a port, and the other way
round. Bracketed entries are now stored in the parser's spelling, with the port kept as written, and
compared with their brackets on; an entry the parser does not read as an address is refused at boot,
naming the entry, as a URL or a wildcard already was. Names and IPv4 entries are unaffected.
A Bot's own decline is only recorded against a Bot the caller may reach
A Bot reports that it declined a request through the person's session, and the audit row says
reportedBy: the Bot itself. The route wrote that row for any agent id in the path, without asking
whether the caller could reach that Bot, so any signed-in person could put a decline, in any words,
against any coworker, one they cannot see included, and an administrator reading the trail would take
it for something the Bot said. The route now asks the store first, as every other route on a Bot
does, and answers not found for a Bot the caller cannot reach, writing nothing.
The engine socket the supervisor is given can be pointed somewhere else
Compose mounted /var/run/docker.sock into the supervisor as a fixed path. That is correct for
Docker, and for Podman on macOS, where podman machine symlinks it to the rootless socket inside the
virtual machine. It is wrong for rootless Podman on Linux, where the path is either absent or, with
podman-docker installed, a symlink to /run/podman/podman.sock, the rootful socket, which is not
the one running. The supervisor held a dead socket and every attempt to give a Bot a computer failed
with a message about not reaching Docker.
The mount source is now ENGINE_SOCKET, defaulting to /var/run/docker.sock, so nothing changes
unless it is set. On rootless Podman on Linux, set it to $XDG_RUNTIME_DIR/podman/podman.sock.
A Bot's computer is waited for properly on Podman, and the supervisor can reach the engine there
Two things stopped OpenBot running on Podman, which nothing had tried before.
The supervisor could not reach the engine at all: The supervisor could not reach Docker. The socket
is there and the mount is right, but Podman's virtual machine runs SELinux and labels the socket in a
way a container is not allowed to read. The supervisor now declares label=disable, which is what
that needs and which changes nothing on Docker.
Then every cold start of a computer raced the first request to it. Readiness was read off the image's
HEALTHCHECK, and Podman does not report one: its images are OCI-manifest, the OCI image config has
no healthcheck field, and the instruction is dropped both when Podman builds an image and when it
pulls one that has it. With no health to read, the supervisor fell back to accepting a container that
was merely running, and a running container is not a browser that is answering, so the first request
arrived at a port nothing was listening on and came back as a computer that is not running. The
supervisor now states the healthcheck when it creates a computer instead of inheriting it, so
readiness no longer depends on how the image was built. On Docker the behaviour is unchanged.
0.0.7
The published service images are zstd rather than gzip
An image pull was already a compressed transfer, so this is not compression where there was none; it
is a better algorithm for the same job. agent-computer goes from 962 MB to 886 MB on the wire, and
zstd inflates several times faster, which on 2 GB of Chromium is worth more than the 8%. The saving
comes from recompressing the layers that arrived from somebody else's registry, where nearly all of
the bytes are, so the images no longer share layers with a gzip pull of the same base.
This applies to the five ghcr.io/copilotkit/openbot-<service> images and not to
ghcr.io/copilotkit/openbot. Reading a zstd layer needs a client that supports it, which Podman and
current containerd do; the single image is pulled by deployments running whatever they have, so it
stays gzip.
A release publishes every service's image, not just the one
ghcr.io/copilotkit/openbot was the only image a release produced, so anything running the Compose
stack built agent-computer, the supervisor, both Bots and the migration image from source on
every machine. That needs a toolchain and it needs several minutes, most of them Chromium, and it
is the difference between a deployment and a laptop being able to start at all.
Each of those is now published beside it, at ghcr.io/copilotkit/openbot-<service>, carrying both
linux/amd64 and linux/arm64 so one reference works on a server and on an arm64 laptop. Every
image gets its own build provenance attestation, and container-images.json on the release pins a
digest for all of them rather than for one.
Nothing changes for a checkout: unset, COMPUTER_IMAGE, SUPERVISOR_IMAGE, BOT_IMAGE,
LANGGRAPH_IMAGE and SERVER_IMAGE name local tags and Compose builds them as before. Point them
at published digests and set IMAGE_PULL_POLICY=missing to pull instead. docs/releasing.md shows
reading the references out of container-images.json; docs/configuration.md lists the settings.
CI now builds those five Dockerfiles too. Nothing did before, because they are built by
docker compose up --build, which only the smoke journey runs and which cannot run in CI, so a
broken one surfaced during a release after the first image had already been pushed.
A skill can be written in the conversation instead of retyped into a form
A skill is four fields and an instruction a Bot follows, and the instruction is the one that decides
whether the skill works. The only place to write it was a textarea on /skills, which meant having
the conversation, getting a good draft in the transcript, and then copying it out and retyping it.
Mostly nobody bothered, which is how a deployment runs for months with no skills in it.
The example package now ships a skill-creator skill, granted to general-assistant. A Bot holding
it is offered four tools for listing, reading and saving skills; every other Bot is offered none of
them. It interviews you about the skill you want, looks at what already exists before naming it,
rehearses it against one realistic request, and then saves it.
The save is a card, not something that happens quietly. It draws the command, the title, the declared
tools and the whole instruction, and writes nothing until a button is pressed. A skill appears in
everybody's / menu with somebody's name on it, and saving is also how an edit is spelled, so an
unattended save could replace a skill somebody is already using.
The tools run in the browser as the signed-in person, over the same POST /api/plugins/skills a
person uses, so who may take a slug is answered the same way and the configuration.changed audit
row is written the same way.
Resetting a computer clears the activity pane
Resetting a Bot's computer deletes the browser profile it worked on, but the activity pane beside the chat went on listing the commands and file operations that ran there. They sat alongside anything the Bot did afterwards with nothing to tell the two apart, and only reloading the page cleared them. The pane now forgets a Bot's history when that Bot's computer is reset. Stopping a browser is unchanged: the profile survives a stop and is meant to resume, so what it did is still true of the machine.
A person can set standing instructions that every coworker follows
Settings now has a box for standing instructions: one piece of text per person, saved once and spliced into every built-in coworker's prompt, in every channel, on every run, including the runs a routine starts overnight. It is the place for what is true of every task rather than of any one of them, such as how somebody wants to be written to or what their company is and is not to be called. A coworker's role still decides what it does; these decide how it does it, and the prompt says so, so an instruction cannot quietly redefine what a coworker is for.
Instructions belong to the person who wrote them. Nobody, administrators included, can read or set somebody else's, and they are deleted with the account. A coworker running at a remote AG-UI endpoint is not sent them, since this deployment does not compose that prompt. Nothing is added to any prompt until somebody writes something, so a deployment where nobody uses this behaves exactly as before.
This adds migration 0026_user_instructions, which creates one table.
A coworker can be made in the conversation, and it starts able to reach nothing
A coworker without an endpoint runs on its role description, which becomes the standing instruction handed to a model on every turn in every channel it is in. It is the hardest thing anybody is asked to write cold, so people write a sentence, get a coworker that answers vaguely, and never go back to the field that decided everything.
The example package now ships a bot-creator skill, granted to general-assistant, with tools for
listing, reading and saving coworkers. It asks the follow-up your last answer calls for, reads the
roster to say when something already does the job, and can be told to make one like an existing
coworker but for a different job, then go and read what that coworker actually runs on.
The card shows the name, the job, the skills and the entire role description, scrolled rather than clamped, because that text runs on somebody's behalf. What is made is granted nothing: it can reach no connector, no tool and no browser until somebody grants it, and a conversation with it says so.
Like the skill tools above, these run in the browser as the signed-in person over the endpoints a
person uses, so who may create a coworker is answered the same way and bot.created carries the
actor.
A conversation has a name of its own
A channel's name was only the names of the Bots in it, so asking one Bot about six unrelated things gave six rows reading the same thing, told apart by a preview of whatever was said last, which is usually the tail of an answer and says nothing about the question. A conversation is now named from its opening exchange, and the roster's second line holds that name instead of the preview, falling back to the preview until a name exists. A row is never blank and never worse off than before.
Two things a deployment should know. The opening exchange, up to 600 code points, is sent to whatever
tenantPackage.model names, which is the same provider the Bots already use, so it is not new egress
but it is sent as housekeeping rather than because somebody asked for it. And the second line now
says what the conversation is about instead of what was last said.
It runs on the work queue rather than as a headless turn, so naming a conversation never takes the Intelligence thread lock and cannot refuse somebody's own next message with a 409. A deployment with no model key names nothing and carries on.
The trail says who a coworker was opened to
Making a coworker public admits every signed-in person to it, and being admitted to a coworker is
being allowed to act as it — with the connectors, the tools and the browser it was granted. It is one
click in the coworker dialog. The bot.created and bot.updated rows recorded the name, the
endpoint and whether a key was set, and said nothing about this, so an edit that opened a coworker to
the whole deployment was byte-identical on the audit page to one that corrected its title. Both rows
now carry the visibility, on every edit rather than only the edit that moved it, so reading the trail
forward says who could reach each coworker at any point.
Duplicating a Bot in the box keeps its instructions
A coworker that runs on this deployment's own Bot has no endpoint — it has a prompt, which is the whole of what makes it that coworker. Duplicate rebuilt every copy from the endpoint alone, found none, and fell back to the managed Bot with the prompt dropped, so the copy carried the name, the title, the role and the avatar and none of the instructions. Its entire instruction became the one sentence of role description, which is the shape behind the compliance answer this repository already has a note about. The two coworkers the default package ships are both of this kind, and one of them is a careful do-not-fabricate instruction. A copy now keeps the prompt and stays a Bot in the box, which also means it can still be granted the right to hand work on — written as a hosted coworker it could never hold that grant, however the original was set up — and copying one no longer needs a managed Bot to fall back to.
Hiding a coworker no longer hides the grants pointing at it
Hiding a coworker is a preference about your own roster — one row per person — and the grants saying which Bots may hand work to it are a deployment-wide fact an administrator set. The Handoff section joined the two, so hiding a coworker from your roster took every grant aimed at it off the screen: the switch was gone, no note said why, and the count above the list quietly dropped by one. Those grants were still in force, because a hop is decided by the grant and not by anybody's roster, so the coworker went on being asked while the only screen that could stop it had stopped listing it. A coworker you have hidden now appears in that list when a grant already points at it, marked as hidden from your roster, so it can be switched off. One you have hidden with nothing granted to it stays hidden.
A tool call that failed no longer reads as one that worked
The audit page draws a row it does not recognise as Allowed, which is right for the many rows that
are neither a refusal nor a failure. Two rows that are failures were falling through to it: a
connector tool call this deployment permitted and the vendor did not complete, and a component's
data read that was granted and then broke. Both were drawn in the same muted colour as a call that
went through, and neither appeared under Did not happen, so the view an administrator opens to ask
what did not work here was short by exactly the rows they came for. A per-person connector fails on
this path every time somebody's token expires, so this was the most common failure the product has
and the one the trail was quietest about. Both now read as Did not happen, and both are in that
saved view. Neither is filed as a refusal: nothing was forbidden on either row.
A blank agentId on a channel activity says which field was wrong
POST /api/channels/:id/activity accepted an agentId of only spaces, trimmed it to nothing, then
looked that up and answered 404 Agent not found. The field was malformed rather than the agent
missing, so the answer sent whoever was integrating to look for a coworker that was never named. It
is now a 400 naming the field, which is what the same endpoint already did for malformed text.
Audit payloads are redacted by the store as well as by its caller
Redaction of secrets out of audit payloads happened in recordAuditEvent, and every caller in the
tree goes through it. The store underneath it is exported, though, and its insert wrote whatever it
was handed, so a future direct caller would have written secrets to the audit table in cleartext.
insert now redacts too. Redaction is idempotent, so nothing about the existing path changes; this
is the floor under it rather than a fix to it.
A stray space in NODE_ENV no longer lets the public example key through
A deployment that never changed KEY_ENCRYPTION_KEY encrypts its credential vault with the key
printed in .env.example, so the server refuses to start with it under NODE_ENV=production. That
refusal compared the variable exactly as written, while the other production refusal beside it —
private-host browsing — trimmed first. Both read the same env file, and a trailing space there is
invisible: Docker's env_file preserves it and so does every hosting dashboard with a text box. So
NODE_ENV=production tripped one refusal, slipped past the other, and started the deployment on the
public key with only a warning at boot. Both gates now ask the same question the same way.
A tool result from an MCP server with an empty part no longer crashes the turn
Reading a tool result cast every part to an object and asked for its type. A null or missing entry,
which a vendor's MCP server is free to send, threw instead, and the turn that had just called the
tool failed. Such a part is now named [unknown], which is the same naming-rather-than-dropping the
surrounding code already does for parts it does not recognise, so the rest of the result still
reaches the Bot.
0.0.6
Setting up needs one Intelligence credential, not two
COPILOTKIT_LICENSE_TOKEN is no longer required. Managed Intelligence derives entitlement from the
project key, so the second credential people were sent to fetch had stopped existing, and startup
was still refusing to boot without it. A deployment now needs INTELLIGENCE_API_URL,
INTELLIGENCE_GATEWAY_WS_URL and INTELLIGENCE_API_KEY. A licence token is still read and still
forwarded to the runtime when set, which is what a self-hosted Intelligence with its own licence
needs.
The Helm chart failed harder than the docs did: it required secrets.licenseToken, so a
managed-Intelligence install was refused at helm install rather than merely misdocumented. That
value is now optional.
Duplicating a coworker keeps the endpoint it was copied from
Duplicate used to point every copy at this deployment's own managed Bot, whatever the coworker being copied ran on. Duplicating one you host yourself gave back something that looked identical on every screen, carried the same name, title and role, and answered from a different process. The copy's connection tab then said it ran here and stopped showing an endpoint at all, so the swap was invisible in the one place you would have checked. A copy now runs where its original ran, and the managed Bot is used only when the coworker being copied had no endpoint of its own, which is the same fallback that applies when you create one without an endpoint. It does not inherit the original's key: that is a reference into the vault, and two coworkers sharing one credential would mean rotating either one's key silently changed the other's, so a copy starts without one. On a deployment with no managed Bot configured, duplicating a coworker that brought its own endpoint now works instead of being refused with advice to give it an endpoint it already had.
Connecting an account survives a vendor that is down
Finishing a connection used to end on a blank server error if the vendor could not be reached at the moment you were sent back, whether that was a refused connection, a name that would not resolve, or fifteen seconds of silence. It now ends where every other failed connect already ended: back on Connected accounts with a note, and nothing stored. Pressing Connect for a vendor this deployment has not introduced itself to yet behaves the same way, answering 502 rather than a server error, and that message now covers a vendor that could not be reached as well as one that turned the registration down.
A connection whose grant cannot be written to the vault ends the same way, rather than on the blank error it used to give somebody who had just finished consenting.
Because the person is told the same thing whatever went wrong, the server log is now where the
difference lives. Three lines to look for: oauth-token-endpoint-unreachable and
oauth-registration-endpoint-unreachable name the vendor and the cause, and
oauth-connection-not-recorded says a consent completed and could not be kept. A fourth,
oauth-token-endpoint-unusable, means the fault is this deployment's catalogue rather than the
vendor.
A custom MCP server token is sent with the scheme it names
Every token stored against a custom MCP server went out as Bearer, whatever the vendor asked for.
A server that forwards the header to an API speaking Basic auth still answers the handshake and the
tool listing, so the Plugins page showed the connector connected and its tools offered, and every
real call came back 401. DataForSEO's hosted server behaves exactly this way.
A token that begins with Basic or Bearer is now sent as written, so paste the credential the
vendor gives you, scheme and all. A bare token is still sent as Bearer, so nothing already
working needs to change.
A conversation is no longer stuck after a tool call went unanswered
A tool that runs in the browser can be torn down while its call is still open, most often because
the tab was closed or reloaded mid-run. The call stayed in the thread with no result, every retry
sent it back up, and the model API refused the whole conversation with Tool result is missing for tool call .... The next three things the person typed failed identically, and the only way out was
to notice that and start another channel.
A chat turn now drops a tool call nothing is going to answer before the conversation reaches the model, on a built-in Bot and on a remote one alike. Routines already did this for the history they seed, and now share the one filter, with a stricter rule than theirs was: a result counts as an answer only if it arrives before the next thing the person said, matching what the model API enforces, so a handler that resolves after the person has typed again no longer looks like an answer. A routine's seeded history that held such a late result used to keep both halves and fail at the model; it now drops both and runs. A result that sits ahead of its own call, or a second answer to a call already answered, is dropped as well rather than sent where no provider accepts it. Ids are never rewritten and the stored thread is untouched, so the transcript still shows what happened and a call waiting on a resume still gets its result. The same filter also covers a Bot answering a relayed question, whose seeded conversation kept every tool call and no tool result.
Reopening a channel no longer hides the end of the last conversation
Opening a channel joins the realtime gateway, and the snapshot the join returns can lag the durable store. When it did, the last exchange of a finished turn was missing from the transcript on every reload, with no unread marker or anything else to explain the gap, and the stored copy never got a chance to replace it because history was only restored into an empty channel.
The stored thread now wins whenever it holds more than the channel does and holds everything the channel already shows. A message typed while history is still loading is not in the store yet, and a run still streaming has messages the store has not seen, so neither is rolled back.
The transcript stays with the question when an answer starts arriving
Sending a message carried it up to the top of the view, correctly, and then the Bot's first token threw the conversation back to its very first message, with the answer being written several screens below the fold. It happened on every turn, from wherever the reader happened to be scrolled, so every answer began with a scroll back down to find it. The transcript now holds the question in place for the whole turn, and the scroll that puts it there is animated rather than a jump — unless the reader has asked their system for reduced motion.
A conversation started from the sidebar is recorded like one started from the home screen
The trail had a channel.routed row for every conversation begun in the home composer — the
coworker it went to and why, whether inferred or named with @ — and nothing at all for one begun
from the sidebar's +, a coworker's card or its profile, which read exactly like a row that failed
to write. Picking a coworker in that To: field is now recorded the same way an @ is.
A browser clock that runs ahead no longer hides what a routine said
The roster line and unread dot for a channel are moved by the last report that arrived, and only ever forwards. A browser whose clock was ahead stamped its report into the future, and then every report from a correct clock — a routine's reply, a relayed handoff answer, another member's browser — was dropped without a word until the real time caught up: the reply was in the thread, and the roster never said so. A reported time is now capped at the server's own clock.
An empty supervisor PORT is unset, not an ephemeral bind
PORT= left blank in compose or a .env used to reach Bun.serve as NaN, so the supervisor
bound a random port while the published mapping still pointed at 4300. Empty now means the default
4300; a non-numeric or out-of-range value refuses to start instead of binding port 30 from a typo
like 30o0.
Tool arguments and results are redacted in the audit trail whatever their spelling
The sensitive-key list redacted tool_result and tool_arguments but not toolResult and
toolArguments, which is the spelling MCP and computer tool calls use. Those payloads were stored
verbatim in audit_events.payload, nested ones included, while every other sensitive key already
carried both spellings. New rows are redacted; rows already written are not rewritten, so a
deployment that has been running MCP or computer tools still holds unredacted arguments and results
in its existing trail.
An IPv6 address listed in AGENT_ENDPOINT_ALLOWED_HOSTS is now actually allowed
A bracketed IPv6 host was normalised one way when the list was read and another way when an endpoint
was checked, so the two could never match: [::1]:8080 became ::1]:8080 on one side and
::1:8080 on the other. Registering a Bot at a listed IPv6 address was refused as a private
address anyway. IPv4 was unaffected.
An empty PORT no longer starts the server on a port nobody asked for
PORT and SERVER_PORT name one number, and either is meant to move the server. A PORT that was
declared but empty — a compose file passing a variable the host never set, or PORT= left in a
.env next to a SERVER_PORT that was set — was read as "set to nothing": SERVER_PORT was
ignored, the number parsed to NaN, and the server came up on an ephemeral port while everything
that polls SERVER_PORT reported it had never started. An empty value now counts as unset, the way
every other setting already treats it, and a value that is not a whole port number (30o1 used to
start the server on port 30) refuses to start instead.
TRUSTED_ORIGINS falls back to the port the app is actually served on
Unset, it fell back to http://localhost:3000, while the app is served on 3010 everywhere else in
this repository. appUrl reads the first trusted origin, so a deployment that left the variable
blank built OAuth redirects against a port nothing was listening on.
Coworkers are made in a wizard and managed in a dialog
Creating a coworker is now a three-step wizard — who it is, who may see it, then where it runs, with Built in offered only when the deployment actually has a managed Bot to run it on. Managing one is a dialog opened from wherever the coworker appears, with sections for its profile (each field edited in place), what it may reach, its connection, handoff grants, routines, and the hide/duplicate/delete verbs — usable on a phone, where the old side panel hid most of this. The panel beside a conversation slims down to who-you-are-talking-to plus two buttons: start a new channel, or open that dialog.
Routines live on each coworker
The sidebar's global Routines entry is gone; a coworker's routines are a section of its own dialog,
since a routine is something it carries out. The /routines page still answers direct links.
Each routine row now wears its state as chips — the channel it posts to, how the last run went, and
either the next run, Paused, or Due when a firing is waiting on the sweep (which used to
render as "Next 5 hours ago").
A built-in coworker is no longer asked for credentials it will never need
A coworker running on the deployment's own Bot was nagged for a callback token and shown an endpoint form. Its connection tab now says what is true — it runs here, nothing to connect, nothing to authenticate. In the same spirit, the handoff panel explains once when a coworker cannot hand work on (it runs as its own agent, outside this deployment's loop) instead of offering switches the server can only refuse; its existing grants stay visible so they can still be revoked.
A conversation is given a name of its own
A channel was labelled with the names of the Bots in it, so every conversation with the same coworker read the same on the roster, and the only thing telling two of them apart was a preview of whatever was said last. That preview is usually the tail of an answer, which says nothing about the question that prompted it. Once a conversation has an opening exchange, the deployment's own model is asked for a few words naming what it is about, and the roster draws those words in place of the preview. A deployment with no model key configured names nothing and looks exactly as it did before.
A channel stops showing a working indicator once its turn has ended
Sending a message and then opening another channel before the reply arrived left the first channel showing three bouncing dots on the roster, and they stayed there after the answer had landed and been drawn into its preview, until the roster was refetched for some unrelated reason. A person's own turn is reported by the browser, because the server is not told when one begins, and that reporting was keyed on state belonging to the channel screen: opening another channel replaced the screen, and the replacement reported the channel it had just opened rather than the one still working. The report now belongs to the turn instead of to the screen, so the channel that was running is the channel told when it stops. Opening a channel also no longer announces that it is idle twice before anything has run in it.
A hop the boundary refused now names the Bot that was refused
The audit page renders its Bot column from payload.bot and nothing else. agent.handoff_offered
and agent.handoff_delivered were given that key; the four rows either side of them — a hop
refused, a hop retried, and a hop that failed for good — were not, so they showed a dash where the
Bot belongs. Those are the rows somebody actually opens the trail for: a hop that happened is visible
in the transcript anyway, and a refused or lost one is visible nowhere else. All four now name the
asking Bot, exactly as the accepted pair and agent.escalated already did.
A failed tool refresh no longer leaves a connector offering nothing
Refreshing a connector's tools replaced the list with a delete and then an insert, as two separate
statements. Whenever the second did not land — a pod killed mid-refresh, a dropped connection, or a
server answering tools/list with the same tool name twice, which the table refuses — the delete had
already committed on its own. The table is shared, so every replica lost that connector's tools at
once, every grant an administrator had made was silently un-offered, and the Bot was told it holds
none of that vendor's tools. Nothing brought them back until somebody read the error on the Plugins
page and pressed Refresh. The two statements are now one, so a bad refresh is recorded and the tools
already held are left alone, which is what the code always claimed to do.
A rule tried in dry-run now says what it would have refused a Bot's tools
dry-run exists so a boundary can be measured against live traffic before it starts refusing
anybody. It worked that way for the browser, and not for connectors: a tool call the rule matched was
recorded only as the call that then went out, so Blocked on the audit page — and any query behind
it — answered "this rule would have refused none of them" about calls it would have refused. A rule
about mcp.server, mcp.tool or mcp.effect therefore looked inert, and enforcing it started
refusing Bots with nothing in the trail to have warned anybody. A refused tool call is now recorded
whatever the mode does with it, carrying carriedOut so a reader can tell a call this deployment
stopped from one dry-run recorded and let past. Enforcing deployments behave exactly as before.
A policy dry-run no longer counts a failed action twice, or invents a change it did not make
Testing a boundary against recent history replayed three kinds of audit row, and one of them is a duplicate: a permitted action that fails is recorded both as the decision that allowed it and as a separate failure row, so every failed action was scanned and scored twice. Worse, a dry-run policy carries a refused action out, so a refused action can fail too — and its two rows disagree, the decision row saying "refused" and the failure row reading as "allowed", so a candidate policy that refused it identically was reported as a new refusal it never introduced. The replay now scores each action once, from the row that recorded its decision.
A message no longer routes to a specialist because a longer word contained a connector's name
When the intent router falls back — it is unreachable, or it declines — and exactly one coworker can reach a system the message names, the message goes to that coworker. The name was matched as a bare substring, so "how do I deal with a slacker" matched the slack connector and "una jirafa" (a giraffe) matched jira: a message naming neither system was pinned, for the life of the thread, to a specialist that could not answer it. A connector's name now has to appear on a word boundary, so a system named on its own still routes and one buried inside another word does not.
The audit page no longer says "Allowed" about six kinds of refusal
A hop one Bot was not allowed to make, an endpoint this deployment would not dial, a rotation the vault refused and a sign-in it turned away were all drawn as Allowed, in the muted colour every ordinary row uses, and none of them appeared under Blocked. The same for a hop that ran out of attempts and a question that reached nobody, which are "Did not happen" rather than allowed. The page recognised six refusal types and the six added since were never added to it. Refusals now read as refusals, the two saved views are built from the same lists the rows are labelled from, and a refusal added later is added in one place or in none.
A conversation deleted while a server was reconnecting no longer lingers on the screen
Announcements between servers travel as Postgres notifications, which reach whoever is subscribed at the moment they are sent and are never replayed. While a server's subscription was down — a database restart, a failover, a rolling upgrade — every channel deletion, pin and message announced in that window was lost, and nothing afterwards asked for it again.
The browser could not notice. Its own connection to the server stayed open throughout, so the refetch it already does when that connection comes back was never triggered, and the roster went on showing a conversation that had been deleted until the page was reloaded.
A server now tells the browsers it is holding to refetch when its subscription is re-established. Nothing to configure, and no change for a deployment whose database connection never drops.
A Bot can answer with a picture instead of describing one
Ask for a chart and a Bot replied in prose, or handed back a fenced block of HTML for somebody to
read instead of look at. Set OPENBOT_GENERATIVE_UI=true and it may answer with an interface it
writes itself, drawn in the transcript. Off unless asked for, and deliberately so: it runs code a
model wrote, so a deployment acquires the capability by choosing it rather than by upgrading.
The sidebar collapses, and the roster is reachable on a phone
The sidebar could always collapse, but nothing in the app ever drew the trigger. The only
affordance was a 16px transparent rail carrying tabIndex={-1}, which the eye could not find and
the keyboard could not reach. Below 768px that same sidebar becomes a sheet whose open state starts
false, so with no trigger the roster was unreachable on a phone, and the roster is how you reach a
channel, Skills, Agents and your own account. There is now a toggle in the header each screen
already draws, with Cmd/Ctrl+B on it, and the collapsed choice survives a reload: the state was
written to a cookie that nothing ever read back. Fifteen screens that previously drew no header bar
gain 40px above their heading, because the toggle has to sit at the pane's edge.
A button drawn as a link answers the keyboard and announces itself
Six controls navigate rather than submit, so they render a router link through the shared button:
New skill, New agent, the sidebar's new-channel control, two empty-state returns, and the back
button that draws on five routes. Base UI was told each was a native <button>, so it wrote
type="button" onto an anchor, where it means nothing, and skipped the two things a non-button
needs: the role="button" that tells a screen reader what the control is, and Space-key
activation, which a <button> gets from the browser and an anchor does not.
A Bot's answer comes back to the conversation that asked
This reverses what 0.0.5 shipped. The 0.0.5 notes below say the asking Bot does not relay text on the addressed Bot's behalf, and the answer lands in that Bot's own conversation. In practice that meant reading the answer somewhere you never asked anything, so it is now the other way around: the addressed Bot works in a scratch conversation nobody is shown, and the asking Bot relays what came back — attributed by name — into the conversation you are watching. What you read is the asking Bot's account of the answer rather than the answer verbatim; very long answers are clipped to keep the relay itself from failing.
Channels say when a Bot is working in them
A channel whose Bot is mid-turn shows a working indicator on its roster avatar — including turns no browser started, such as a handoff running on the server or a routine. An open conversation also picks up turns that arrived while nobody here streamed them, so a relayed answer appears without leaving and coming back.
First sign-in gets an onboarding wizard
A new person lands in a short welcome wizard before the app; everyone who signed in before this upgrade is stamped as already onboarded by the migration and sees nothing.
Shift+N starts a new chat from anywhere
Bound across the signed-in app, shown under Settings → Keyboard shortcuts, and inert while you are typing in a field. Handoff work is also picked up the moment it is queued rather than at the next poll, so an answer's round trip no longer pays up to two seconds per leg.
A Bot's shell can no longer reach the embedded database without a password
In the all-in-one image the cluster was trust-auth on loopback, and the Bot's shell runs in the
same container: it could psql -h 127.0.0.1 -U openbot with no password and read the audit trail,
the policy store, and the credential vault as the instance owner. The cluster now uses
scram-sha-256 with a password generated on first init and kept beside the data, handed to the API
over the container environment. The shell has no way to learn it, so the connection is refused. An
external DATABASE_URL deployment is unaffected.
A live screen that ends says so, instead of freezing the last frame
When a Bot's live screen ended — the computer stopped, or the socket failed — the message explaining why was drawn only by a component the take-the-wheel view does not mount, so the screen sat frozen on its last frame with nothing said. The reason is now shown where the live screen is.
A Bot's browser drops the automation flags a person needs gone to sign in
The browser announced itself as automated (navigator.webdriver, the enable-automation switch),
which sites like Google refuse even when a real person has taken the wheel. Those flags are now off
at the source — the browser flag, not a script that patches navigator.webdriver and leaves the
other tells. A headless build still reports HeadlessChrome in its user agent, which only running
headed under a virtual display removes; that heavier change is tracked separately.
An empty model reply, or a run with no question, no longer ends in silence
Two failures on strict OpenAI-compatible providers (z.ai GLM, Anthropic): a follow-up run that carried only tool deltas and no human turn was refused outright, and a reply with no text and no tool call ended the run with nothing on screen. A run with no human turn now carries a neutral continuation, and an empty reply ends on a visible line rather than in silence. OpenAI, which tolerated both, is unchanged.
Embedded PostgreSQL initialises on a platform volume, and says so when it cannot
EMBEDDED_POSTGRES=on could not create its cluster on a platform whose persistent volume is an ext4
mount — Railway, and by the same mechanism most others — and it failed differently depending on where
the volume was mounted. Neither of the two paths this repo suggested worked, and the two suggestions
disagreed with each other: docs/deployment.md said /var/lib/postgresql/data, the Dockerfile
comment said /var/lib/postgresql.
Mounted at the parent, the mount arrives owned by root, data is not in it, and the image's
build-time chown is hidden underneath — so initdb, which has already dropped to the postgres
user, cannot create the directory. postgres-init now creates and chowns it first, as root, which is
the only step in a position to. This also fixes the plain
docker run -v openbot-data:/var/lib/postgresql case, which relied entirely on that hidden chown.
Mounted directly on the data directory, the mount arrives holding a lost+found, and initdb will
not initialise into a directory with anything in it. The documented mount is now the parent,
/var/lib/postgresql, which leaves data an ordinary subdirectory — what PostgreSQL's own hint
asks for, and what the Dockerfile already said. A volume already mounted at
/var/lib/postgresql/data and working — a Docker named volume, which arrives empty rather than with a
lost+found — keeps working and needs no change.
The failure said nothing useful. api waits on postgres and migrate, so neither started, the
container came up anyway, the platform reported the deploy a success, and the public URL served a
persistent 502 with the real reason visible only in the container log. A data directory that holds no
cluster and is not empty is now refused with a sentence naming the mount to use instead.
Reported by @jerelvelarde with the container logs for both mount paths, which is what made the two failure modes separable.
Turning on network policies no longer leaves the culler pod open
networkPolicy.enabled rendered policies selecting the server and the computers. The culler
CronJob's pod carries component: culler and was selected by neither, and a pod no policy selects
keeps the cluster default rather than being denied. So the switch fenced the API and the computers
and left open the one pod that wakes every five minutes carrying the API's whole environment,
KEY_ENCRYPTION_KEY and BETTER_AUTH_SECRET included, with a token allowed to create, patch and
delete Sandboxes. It has a third policy now, narrower than the other two, and
networkPolicy.cullerExtraEgress narrows its database egress separately from extraEgress. A
render that leaves any pod unfenced is refused by the chart checks.
A sign-in a site opens in a new window is shown, and can be clicked
A Bot's browser was bound to the page it launched with, and to nothing the site opened afterwards. Anything arriving in a new window or tab was invisible on the live screen and unreachable by input, so the popup sign-ins that a person takes the wheel to complete were exactly the ones they could not complete. Worse than invisible: a click at the place the popup's button was drawn went to the page underneath it, so a person trying to finish a sign-in could navigate the page the Bot was working on without seeing either result.
The browser now follows the window the site opens, and returns to the opener when it closes, which is what a sign-in popup does when it succeeds. A snapshot taken before the change of page is refused afterwards with the same "take a new snapshot" it already gives after a navigation, so a stale ref cannot act on the wrong document.
Nothing to configure.
Stopping a Bot's computer stops it, and the person watching is told
A computer somebody stopped came back up on its own about a second later, and reset did the same. The live screen kept a loop asking for the Bot's current page once a second, asking for a page is what starts a browser, and nothing tore that loop down when the browser it was showing went away. The same loop kept the browser marked recently used, so a Bot with somebody watching was also immune to the idle timeout and came straight back after being closed to stay under the cap on running browsers. Those last two never involved a request at all, so nothing on the stop path could have covered them.
Two smaller failures went with it. A person who reconnected, leaving their old window open, could have that old window's typing land in the page the new one was watching, with nothing said to either. And a window closed while the browser was still starting left a screencast and its loop behind for a connection that had already gone.
The screen is now held per connection rather than per Bot, so closing one only ever ends its own, and teardown hangs off the browser closing rather than off the two requests that ask for it. A viewer whose screen ends is sent a message saying why, whether the computer stopped, was reset, or the screen was taken over by another window.
Nothing to configure, and no change for a deployment where nobody watches a Bot work. The app does not yet show that message: it arrives at the browser and is held in state the live screen does not read, so a person still sees the last frame until they reopen the screen. That half is tracked separately in #287.
0.0.5
One Bot can hand work to another, and reach a person when no Bot will do
A Bot asked something it is not the right Bot for can now put the question to one that is. The addressed Bot answers as itself, in its own conversation, with its own tools and its own knowledge. The asking Bot does not relay text on its behalf, so what you read is the answer that Bot actually gave rather than another Bot's summary of it. (Reversed since: see Unreleased — the answer is now relayed back into the conversation that asked.) The asking conversation records that the question was put and to whom. A Bot that judges no other Bot will do can instead reach the person who asked it.
No Bot may address any other until an administrator says so. Which Bot may reach which is an ordinary grant, made per Bot on that Bot's own screen under Bots it may ask, and a Bot with no grant is told it cannot rather than quietly trying. The pair is directional: that list is who this Bot may ask, not who may ask it, so letting two Bots ask each other is two switches. A Bot addressed by a name two Bots answer to is refused and both are named, because picking one would be a guess about which colleague a person meant.
Two ceilings, because a Bot deciding to ask another Bot is a Bot deciding to spend a run:
BOT_HANDOFF_MAX_DEPTH is how many Bots deep a chain may go and defaults to 1, and 0 switches
the capability off entirely: the tool is not offered rather than offered and refused.
BOT_HANDOFF_MAX_PER_RUN is how many Bots one run may address and defaults to 3. The Helm chart
takes the same two as config.handoff.maxDepth and config.handoff.maxPerRun.
A hop that fails is reported back by the Bot that asked, after its attempts are spent, rather than leaving the person watching a conversation that never finishes. One rough edge to know about: a hop that is retried leaves one "asked" line per attempt in the addressed Bot's own transcript, so a hop that took three attempts reads there as having been asked three times.
No new tables: this uses the work queue that already fires the culler.
A conversation that used a tool no longer stops answering for good
A channel could reach a state where every turn in it failed and the only thing it said was
Tool result is missing for tool call call_…. Not the turn: the conversation. Everything sent
afterwards failed the same way, including a question as ordinary as what two plus two is, and there
was nothing a person could do to it from the screen.
A tool result is matched to the call above it, and a thread read back from the platform does not always carry the two in that order. Where the result was stored ahead of its own call, this deployment counted the call answered, sent the history on unchanged, and the model provider rejected the whole conversation while assembling it. Handing work to another Bot, asking a person, and calling a connector's tool could each leave a thread in that shape.
A result now only answers a call it follows. One that arrives early is moved to sit after its call, keeping what it actually said, and a result whose call is nowhere in the thread is dropped. Affected conversations start answering again on their own; there is nothing to run and nothing to reset.
The framework Bot answers on 5.6-tier models, and can be told how hard to think
Pointing BOT_MODEL at a gpt-5.6-* model gave a Bot that started, reported healthy, and then said
nothing: every run was a RUN_STARTED and a RUN_FINISHED with no text between them. Those models are
run on the Responses API, which streams content blocks where chat completions streams a string, and
the run read only the string — so every delta was dropped on the floor. Both shapes are read now.
Nothing changes for a deployment on 5.5 or on Anthropic or Google.
BOT_REASONING_EFFORT sets how hard a reasoning model thinks: none, minimal, low, medium,
high, xhigh or max. Unset, the model keeps its provider's default. A value the API does not
have, or one set where it cannot be sent — a provider that is not OpenAI, or a model not on the
Responses API — stops the Bot at startup with a message naming what to change, rather than starting
with a setting that goes nowhere.
A Bot can be asked to do something on a schedule
"Every weekday at nine, post the standup notes here" is now something a Bot can be asked rather than something somebody has to remember. A routine created this way runs under its own creator's grants — it can do exactly what they could do in chat, and nothing more — and its reply lands in the channel as an ordinary Bot message: it lights the unread dot the same way any other message does, and it appears in the transcript rather than anywhere separate. A routine that fails posts one message about its first failure and, after ten in a row, switches itself off with a final one rather than failing forever unnoticed.
The deployment gains two tables, via migration 0021.
This needs a new process. A worker fires due routines by calling this deployment's own API server,
and a deployment that never starts one schedules nothing — the routine sits on the Routines page with
a next run time like any other, and nothing on the screen says a worker is missing. WORKER_SHARED_SECRET
is the credential the worker presents; a deployment without it configured refuses every handoff rather
than accepting one it cannot attribute. scripts/start.sh runs the worker locally; the Helm chart
turns it on with routines.enabled and takes the secret as secrets.workerSharedSecret. No new port
is opened for any of this — the worker only ever calls out to the server it already trusts.
Turn screenshots are swept in every deployment, not one
A page a Bot opens is photographed and kept in computer_page_frame, so a conversation read back
later shows what it was looking at. The reaper for those rows had one caller: the idle-computer
culler, which refuses to run unless each Bot has its own computer and is scheduled only by the Helm
chart's CronJob, which exists only when computers.mode is sandbox. On Compose, on the all-in-one
image, and on the chart's own default of shared, nothing ever called it. One browsing Bot over
ninety days is several hundred megabytes of rows that nothing was ever going to remove.
The sweep now runs on the server, on the same hourly timer that removes old audit rows, and does not wait for a retention policy to be configured: a month of screenshots is what the store already meant to keep. It also removes them in batches, because one statement over that much data held its locks for seventeen seconds.
Deployments using computers.mode: sandbox are unaffected in what they keep. The culler no longer
purges frames, because the server does it there too and one owner is better than two.
On upgrade, the first sweep removes the backlog. A deployment that has been keeping every screenshot since it was installed will lose the ones older than a month, about a minute after the server starts. That is the window the store has always documented and the one sandbox deployments have been enforcing, but it has never been applied anywhere else, so it is worth knowing before the upgrade rather than after. It is drained in batches, forty thousand rows an hour, rather than in one statement.
A channel a Bot has spoken in unseen shows a dot
The sidebar marks a channel when a Bot has said something since you last had it open: a dot beside the preview, the name a touch heavier. Opening the channel clears it, your own messages never set it, and the channel you are looking at never shows it. The marker is yours alone — per member, on the membership row like the pin — so one person reading does not clear anybody else's dot.
The deployment gains one nullable column, via migration 0019.
The API can reach Intelligence and sign-in when a NetworkPolicy is on
networkPolicy.enabled wrote a rule for the API server that named DNS, the database and the Bots'
computers, and nothing on 443. On a cluster that enforces policy the server could therefore reach
neither CopilotKit Intelligence, nor an identity provider, nor a Bot: nobody could sign in and no
conversation ran. Two of the five shipped ci/ targets turn the policy on, and on GKE enforcement is
the default and cannot be switched off.
Nothing said so. The pod passed every probe and stayed Ready, because /health answers from a
literal, so the first evidence was a timeout to a hostname that read as the internet being down.
The API now reaches HTTP and HTTPS everywhere outside the cluster's private ranges, in every
computers.mode rather than only sandbox, cut by the same exception list the computers' own policy
uses. It still cannot address another pod, a node, or a cloud metadata endpoint.
mode: sandbox had been working only because a rule meant for the Kubernetes API server carried no
destination and so permitted everything. That rule now covers the API server alone, and
networkPolicy.kubernetesApiCidr narrows it to your cluster's service range; left empty it stays as
it was, because a chart cannot know that range.
Taking the wheel stops the Bot's shell, not just its clicks
While a person held the wheel the Bot was refused on the page, and not in the shell. /exec and a
workspace write went through, so a Bot could keep running commands and rewriting its /workspace
underneath somebody who had taken the browser at a login wall. The guard existed and covered
navigation and the four page actions; the shell arrived later and was never wired to it.
Every acting path now asks the same question in one place, so the property the documentation states
is the property the computer has. Reading is deliberately not acting: /files/read and
/files/list still answer while a person drives, because a Bot that has just been stopped still has
to be able to say what it was doing.
Nothing to configure. A Bot that acts during a takeover gets the refusal it already got for a click, and the trail records the attempt and the failure the same way.
A computer that was suspended once suspends again
Scale-to-zero worked once per Bot. A computer suspended, resumed, used and then left alone again was offered for suspension on every sweep after that and never suspended, and stayed awake until the next day. Nothing reported it, because a sweep that offers work and suspends nothing looks exactly like a fleet that is busy.
The queue keys a suspension on the Bot id and keeps the finished row so that a late offer of the same key collides with it rather than running the work twice. Both are right. What was wrong is that the finished row was kept for a day, which is the window the other half of the sweep needs: a suspension that keeps failing is held back that long before anything tries it again. One number could not be both, so there are now two, and a finished suspension is kept for the idle window instead. That is the same clock the offer runs on, so a Bot cannot come back round as idle until its row has gone.
Nothing to configure, and the sweep already runs on a schedule. A deployment where each Bot has its own computer stops paying for browsers that were used once.
A Bot's egress proxy is reachable on Kubernetes, or the install is refused
The chart named no egress variable anywhere, so a Helm deployment read the per-Bot proxy settings
nowhere and every Bot went out directly. They were always settable through computers.extraEnv,
which reaches the computer in both the shared and the sandbox arrangement, but nothing in the chart
or its README said so, and a setting whose whole purpose is to give a security team a per-Bot
address is not one to leave undocumented.
The other half is that setting it was not enough. A computer is allowed 80 and 443 to public
addresses and nothing else, which is almost no proxies: they sit on a private address, or on 3128 or
8080. So a proxy the network policy provably blocks is now refused at helm install, naming
networkPolicy.computerExtraEgress, rather than found later as a Bot that fails on every page.
Nothing changes for a deployment that sets no proxy, or one that already opened a path to it.
A finished turn shows the page it opened, not the one open now
Reopening a conversation made every past turn fetch the screen as it is now, so an answer about Hacker News from an hour ago sat under a picture of whatever the Bot had open since.
A page is now photographed where it is opened. The server takes the frame the moment a navigation
succeeds and keeps it in computer_page_frame under the computer and the address, which is the one
moment the screen is certainly showing the page that was asked for. Reopening the conversation shows
that frame rather than the live screen, and a turn with nothing kept names the page instead of
drawing the wrong one.
The surface used to capture it itself once the turn went quiet, and that is a race it cannot win: a reopened turn and one that has just finished are indistinguishable from inside the component, the same computer is driven by other conversations in between, and a resumed computer starts blank. It filed pictures of pages the turn never opened, or none at all. It only reads now.
Redeploy the computers with the server. A screenshot only says which page it is of on an
agent-computer built after that field was added, and this is what decides whether a frame is kept.
Where each Bot has a computer of its own there is nobody to race with, so an old computer's picture is
accepted and the feature works through a rollout. On ONE SHARED COMPUTER it cannot be: another Bot's
navigation lands between the navigation and the picture, and a frame that cannot be told apart from
theirs is refused. So a shared-computer deployment that updates the server and not the computer keeps
no frames until it does, and says so in the server log each time rather than leaving somebody to
wonder.
Two things followed from making a past turn a record. Its placeholder is decided by the turn being over rather than by whether a live frame happens to be in hand, because a tile that was live a moment ago keeps its last screenshot and used to fall through to "Waiting for the assistant's screen…" and wait there for ever. And opening one full size shows that same kept frame, with no live stream and no wheel: zooming a past turn used to mount the socket and offer Take control, so the one gesture for looking closer at what a turn did replaced it with whatever the Bot has open now.
A conversation keeps the browsing that produced its answers
Every turn in which a Bot used a tool was disappearing from the transcript on reload. The sentence the Bot wrote stayed; the browsing that produced it did not, the inline screen went with it, and the footer said some messages could not be read.
The history store writes a tool call as {id, name, args}. AG-UI describes
{id, type: "function", function: {name, arguments}}. The reader validated against the second,
treated the first as damage from an interrupted run, and dropped it. It is not damage: it is how
every tool call is stored, so what looked like a guard against one bad turn was deleting all of the
real ones. Observed on a live thread where every browsing turn was counted unreadable and every one
of them was well formed in the store's own dialect.
The two spellings are now read as the same thing. The check stays for turns that really are malformed, and a mixed or unrecognised array is still refused rather than half-translated, because a reader that rewrites what it does not recognise is worse than one that refuses it.
Run this on Kubernetes
A Helm chart under charts/openbot, Bots and all, and the fixes that installing it for real turned
up. Proven on a real EKS cluster: five workloads, replicas across two nodes, EBS volumes bound, and a
Bot opening a real page from inside AWS with the decision in the audit trail.
One chart, five targets: EKS with a shared browser, EKS with a computer for each Bot, GKE, AKS and
somebody's own cluster, with nothing but values between them. There is no cloud branching in any template. Every place the clouds genuinely differ is a
value whose default is what a plain self-hosted cluster does: the cluster's own default StorageClass,
no RuntimeClass, a plain Kubernetes Secret, an Ingress. Identity is one serviceAccount.annotations
map, which is all IRSA, Workload Identity and AKS workload identity are. Secrets are a plain Secret
by default and an ExternalSecret against any backend when asked, so Secrets Manager, Secret Manager
and Key Vault are a values block rather than three code paths. Gateway API is supported beside
Ingress rather than instead of it. charts/openbot/ci holds a values file per target.
Two replicas by default, because horizontal is the point and one replica hides every bug that is
not. A bad install is refused at helm install, naming the value to change, rather than discovered
in a crash loop: no database or two of them, nobody who could sign in, nobody who would be an
administrator, a key of the wrong shape, both routers enabled, or a browser asked for inside more
than one replica.
A Bot's computer is not in an API pod. The image runs one beside the API so that a single
container works on its own, and EMBEDDED_COMPUTER=off turns it off. A replica must not carry a
browser: it is a few hundred megabytes holding one Bot's logins, so scaling the API would scale
those with it.
Migrations no longer need a development tool. bun x drizzle-kit migrate cannot run in the
shipped image at all. The CLI reads a TypeScript config, which needs the esbuild that
bun install --production correctly leaves out, so it printed "Reading config file", exited 1 and
said nothing else. EMBEDDED_POSTGRES=on was therefore starting a container whose database was
never migrated, and the first symptom was the API reporting that users does not exist.
server/scripts/migrate.ts uses the migrator inside drizzle-orm, which is a runtime dependency
already, and keeps the same journal, so a database migrated by either tool is migrated.
A computer for each Bot, suspended when idle. computers.mode: sandbox gives every Bot its own
browser as a Sandbox from kubernetes-sigs/agent-sandbox, which is built for this workload: an
isolated, stateful, singleton pod with a stable identity and persistent storage. Suspending is one
field, and it keeps the volumes, so a computer comes back with its logins rather than signed out of
everything. shared stays the default and needs nothing installed in the cluster.
The NetworkPolicy would have fenced the API off from its own work. Its egress named DNS and the
bundled database and nothing else, so on a cluster that enforces policy the API could not have
reached a Bot's computer or, with a managed database, the database. Both are allowed now, and turning
the policy on with an external database and no rule for it is refused rather than shipped. Worth
knowing either way: EKS runs its CNI with --enable-network-policy=false, so a policy there installs,
looks right, and does nothing at all.
A cluster with no controller is refused at install. computers.mode: sandbox needs the
agent-sandbox CRD, and without it the install succeeds, every pod is healthy, and the deployment
looks finished until the first Bot asks for a browser. The chart reads the cluster and refuses,
naming the one command that fixes it.
What decides a computer is idle is the audit trail, not the browser. Asking the browser would wake it, so every computer anything asked about would come back up and the bill would never fall.
Durable work, claimed by whichever replica gets there first. work_items plus
select ... for update skip locked and a lease: no coordinator, no leader election, and a replica
added is throughput added. The idle-computer culler is its first user; scheduled routines and
hand-offs between Bots are the other two, which is why it is written once rather than three times
slightly differently. A CronJob runs the sweep, because a timer in the API fires in every replica and
suspending a browser somebody just started using is not something to do five times.
Which run of a computer this is, across a suspend. A resumed browser counts snapshot
generations from one again, so a ref the model still holds from before the suspend would match a row
nothing has overwritten and the boundary would decide about an element on a page that no longer
exists. The first answer here used the node and the pod address, and resuming a real computer
disproved it: a suspended sandbox is very often rescheduled onto the same node and handed the same
address back, so both were identical across a suspend and resume and the check would have said "same
run" for the exact case it exists to catch. It reads the Ready condition's transition time instead,
which moves every time a computer starts serving again.
Which run of a computer this is, on more than one replica. sessionOf answered from a map in
the process that started the computer, which is right until there are two: the replica that took a
snapshot is usually not the one handling the click, and the second had nothing to answer with. An
unknown session means "no opinion" and skips the generation check, so on exactly the deployment
shape it was written for, the check that stops a ref from a replaced computer resolving against a
live one was silently absent. It now asks the supervisor when it does not know, by listing rather
than by ensuring, so asking never starts a computer that had stopped.
A routing trail says why a message was not routed, not only that it was not
Every untagged message writes a channel.routed row, and that row carried fallback: true for two
completely different situations: the router answering honestly that no specialist was a confident
match, which is the feature working, and the router not answering at all, which is an endpoint that is
down. Both read identically, so a deployment whose router had stopped working looked like one whose
messages were simply hard to route.
That is not hypothetical. The intent router spent an unknown period 404'ing on every deployment that
set OPENAI_BASE_URL, because a /v1 was appended to a URL that already had one. It was fixed in
0.0.3, whose own note says untagged messages "silently stopped being routed and nothing said why".
The row now carries undecided, naming the cause: unreachable, unparsed, off-roster,
unconfident, or one-candidate — and null when the router did decide. Named values rather than a
sentence, because the useful question is how often, and a count needs something to group by.
Two smaller corrections came with it. A message routed to the only coworker that can reach the system it names kept that as its reason and threw the cause away, so a router that had been down for a week produced rows reading like reach-based routing working as intended; the cause now survives that path. And an answer containing no JSON at all — a model replying in prose — was recorded as the router naming a coworker off the roster, which sends whoever reads it to look at their roster rather than at the model. It is now reported as unparsed, which is what it is.
Nothing changes about where a message goes. Every routing decision is the same decision it was.
Notion joins the connector catalogue
Notion is now a governed MCP connector, reached through Notion's own hosted server on the catalogue's default transport, as the person asking — the same grant, policy and audit machinery Google Drive already runs through. Unlike Drive, it ships both read and write tools from the start; the writing ones are named in the catalogue, and an advertised tool absent from that list classifies as a read — so reconciling the write-tool names against what Notion's hosted server actually calls them, on the first Refresh tools, is required, not cosmetic. A tool the server never advertised at all still classifies as a write, same as any other connector.
There is no client to register: this deployment introduces itself to Notion on first connect. That
shortens setup but does not finish it — unlike Drive, whose tool list is this codebase's own code,
Notion's tool list is an answer from Notion's hosted server, so a deployment has recorded none of it
until Refresh tools has run at least once; and, like every other connector, a Bot gets nothing until
its tools are granted to it. Setup is enable at /admin/plugins/notion, connect an account at
/settings/connected-accounts, refresh tools, then grant — a bulk Grant tools… dialog on
/admin/plugins/notion grants a batch of tools to a batch of Bots in one pass, one grant and one
audit row per Bot per tool. No migration.
Refresh tokens rotate in place, and replicas take turns spending them
A vendor that rotates refresh tokens invalidates the one it just handed out, so two replicas racing to use a stale token would have the loser refused, or worse: a rotating vendor's reuse detection can read that as a stolen token and revoke the whole connection. Every plugin call that mints an access token now locks the credential's vault row for the length of the exchange, so a second replica waits rather than races, and the rotated token is written back in the same transaction that held the lock. Nothing to configure; a connection just stops going stale under concurrent traffic.
An MCP token is spent only by its own server, and only at the address it was given
Pointing a server at a credential is the one place this deployment takes a reference to a stored secret rather than the secret itself. Everywhere else, the value was typed into the same request that stores it: a Bot's key is minted from what an administrator pasted and the id it gets is nobody's to choose. So this is the one field where which secret and which address could be made to disagree, and the add settles the disagreement by spending the credential: the tool refresh runs before the call returns and sends what it decrypts to the URL from that same request.
Two ways they could disagree, and both are now refused. A server could be pointed at any mcp
credential in the vault, including one minted for a different vendor, so a token given to one server
was deliverable to another. And re-adding a server with a different URL rewrote the address while
keeping the credential, so the same token could be sent somewhere else entirely with no
cross-server trick at all: the token really did belong to that server, and only the address moved.
The second is why the first was not enough on its own. A credential now has to belong to the server it is attached to, and a server that already holds one cannot be re-added at a different address. Correcting a title or retrying an interrupted add sends the same URL and is unaffected. A server holding no credential can still be re-addressed, because there is nothing to misdirect. Moving a server that does hold one means removing it and adding it again with the token the new address is meant to have, which is the honest description of what has happened anyway.
This matters more than "an administrator could misconfigure something". A stored credential cannot be read back by anybody, by design: the credentials screen answers that a credential exists and never what it is. These two shapes were the way around that, so a deployment where somebody has used them should treat the credentials involved as disclosed and rotate them.
A token also stops outliving the server it was minted for. Re-adding a server without naming a credential used to clear the pointer while leaving the credential live, and removing a server retires its token by reading it off that pointer, so a cleared one meant the token survived its server and could be attached to a freshly created one at any address, where there was no longer a stored address to compare against. Three ordinary acts in a row and the binding above stopped meaning anything. The pointer now survives a re-add that names none, removal therefore finds and retires it, and a retired credential is refused rather than quietly attached to fail on its next call.
Curated servers keep working as they did. Their URL comes from the catalogue rather than the request, and a per-instance hostname is matched against the vendor's own anchored pattern before anything is stored, so re-adding one cannot point it at an address of the caller's choosing.
A configured egress proxy reaches the browser that uses it
EGRESS_PROXY_DEFAULT and EGRESS_PROXY_<BOT> were documented as the way to give a Bot a stable
outbound address, and Compose passed neither to anything. docker-compose.yml named no egress
variable and had no env_file, so the shared computer resolved every Bot to no proxy and went out
directly, and under the supervisor the same emptiness meant there was nothing to forward into the
computers it creates.
The failure was silent, which for a setting whose purpose is to give a security team a per-Bot address for network rules is the worst of the available failures. The stack started, the browser left by the host, and the Computers screen reported "Leaves directly" because it was reading the same empty environment.
They now live in egress.env, which both the computer and the supervisor are given. A file rather
than more environment: entries because EGRESS_PROXY_<BOT> is derived from a Bot's id and there
is no fixed set of names to list; a file of its own rather than .env because that one holds the
deployment's secrets and the container running a browser and a Bot's shell is deliberately not
given them. It is optional, so a deployment with no proxy is unchanged, and gitignored, because a
proxy URL can carry a password.
Move these two out of .env and into egress.env. In .env they reach no process.
Screens without a conversation stop polling for a Bot that does not exist
Every surface asks which components its Bot holds, and asks again every few seconds so a revoked grant leaves an open conversation quickly. The Bot it asked about was whichever one the surface declared — and on a screen with no conversation at all, that was the placeholder id the routing holder falls back to, which no package registers and the server answers 404 for. An admin page left open polled a guaranteed miss every five seconds, indefinitely.
Nothing looked wrong. The screen rendered, because an absent grant list and an empty one draw the same. The cost was the noise: a request log where the same 404 repeats forever is one where the 404 that matters is invisible.
The grant queries now wait for a surface to declare a real Bot, and simply do not run while the placeholder holds. Conversation surfaces — the Bot page, channels — declare one and are unchanged.
A rule can be tested against history before it is saved
A boundary was written blind: an administrator typed a CEL rule, saved it, and learned what it actually matches from the refusals it produced in production. The trail already records every judged computer action with the same facts the gateway judged it on, so the question "what would this rule have done" had an answer nobody could ask.
The Boundaries page now has Test first beside Add rule. The candidate — the current policy plus the drafted rule — is replayed over recent recorded actions, and the reply names each one it would have decided differently and the rule that would have decided it. Nothing is saved and nothing is decided; no audit row is written, because no action was permitted or refused.
Replay, not simulation: the context is rebuilt from the audit row exactly as the gateway built it at decision time, through the same helpers, so a rule behaves here as it will behave live. The scan is bounded and biased to recency, and the reply says how many rows it covered.
A browser refusal names the element again
Every browser context carries a neutral all-empty mcp object, so a rule naming mcp.effect
evaluates to false instead of throwing. The refusal copy keyed on that object being present rather
than on its contents, so every live browser refusal took the tool-call branch and read
": on is blocked" — two empty strings where the element and the page belonged. The tests passed,
because their contexts omitted the field the gateway always attaches.
The branch now keys on the server and tool being named, which a real tool call always has. A refused click reads "“Submit order” on shop.example is blocked by the rule ..." again, which is what the Bot relays to the person asking.
Knowledge searches instead of guessing
A package can say which of its skills each coworker gets, and the fintech example gives Knowledge the four document skills it ships.
Knowledge is one of three coworkers in the box, described as answering company questions and citing sources. The skills that would let it do that were seeded attached to nobody, so every clone started with them paired to no Bot: the per-run narrowing that skills exist for was switched off until somebody opened the Skills page and made the pairing by hand, in each deployment, again after each new connector. The pairing belongs with the package, which wrote both files and knows which coworker it meant them for.
THIS GRANTS NOTHING, which is what makes it safe to seed. A skill is an instruction; what a Bot may call is its grants, and the offer each run is the intersection of the two. A skill naming a tool its Bot does not hold loads nothing. Seeding an MCP grant would be the opposite, because those reach a person's own account, so those stay an administrator's decision and are untouched here.
A redeploy takes back only what the package gave. Grants it made carry tenant-package, and a grant
an administrator made through the Skills page keeps their name and survives, because a deploy quietly
undoing a deliberate decision is the kind of change nobody traces back to the deploy that caused it.
A coworker naming a skill its package does not ship is refused at load rather than dropped, the same
as a channel naming an agent that is not there: a typo that silently attaches nothing looks exactly
like working.
A Bot's computer is no longer on the same network as the database
Compose declared no networks, so every service shared one and reached the others by service name.
One of those services is the container a Bot's shell runs in, and another is PostgreSQL, whose
username and password are in the same file. A shell reaches whatever its container reaches, so a Bot
could open postgres:5432 and authenticate: the audit trail, the policy store and the agent tables,
from the one container whose job is to run what a Bot asks for. The role Compose creates is the
instance owner, so the trail's append-only trigger was no defence either, being something its owner
can drop.
PostgreSQL and migrate, the only service that reaches it by name, are now on a data network of
their own. Everything else stays where it was. Nothing changes for a deployment that runs the API
server on the host, which reaches the database through the published port and never used the shared
network for it. A deployment that runs the server inside Compose has to join that service to both
networks, which is the one place the two are meant to meet.
The published port is now on loopback, as every other port in that file already was. Taking the
database off the Bots' network removes the name, not the address: a container's default gateway is
the host, and a port published on every interface answers there. From inside the computer container,
the gateway on 5432 accepted a connection and began authenticating as openbot on openbot, with
the password in the same file. A deployment that reached the database from another machine over
this port has to reach it another way, which is what publishing it on every interface was doing.
This does not reach back in time. A deployment that has been running with the two on one network should assume a Bot could have read or written the database, and look at the trail with that in mind.
A credential in an MCP server address is refused in the query and the fragment too
Refusing https://user:[email protected]/mcp closed the userinfo spelling of a credential in the
address and left the two obvious ones open. ?token=, ?api_key= and their neighbours were still
accepted, and the address is stored and named in the trail exactly as given: audit redaction keys on
the field name, url is not a sensitive one, so the secret was written to mcp_servers and to an
append-only audit row in clear text. That is the same disclosure the userinfo rule exists to prevent,
one character away.
A parameter whose name reads as a credential is now refused, in the query string and in the fragment,
and the refusal points at the token field without repeating what was typed. The name is read rather
than matched against a list, so ?auth_token=, ?x-api-key= and ?X-Amz-Signature= are refused
alongside ?token=: a rule that only catches the spellings somebody thought of reads as a guard
while behaving like a gap. The test is on the parameter name rather than on the presence of a query,
because vendors route and version with parameters and a floor that refused every one of them would
be one an operator works around instead of with. https://mcp.example.com/mcp?workspace=acme&version=2
is unaffected, and so is an ordinary fragment. A credential written into the path is still
accepted: it is indistinguishable from a route, and at least one hosted provider addresses servers
that way. A deployment where somebody has put a credential in an address should treat it as
disclosed and rotate it, for the same reason as before: the audit row cannot be deleted.
metadata.goog is refused too. It is Google's own short name for the metadata server, published
beside metadata.google.internal, and it carries a dot and none of the suffixes this check lists, so
it read as an ordinary vendor name. The long spelling was only ever refused incidentally, by the
.internal rule. Both are now named, so the address this check was written for is refused on purpose
rather than by luck.
A curated MCP server is pointed at its own kind of credential too
Adding a server by URL was made to check which credential it is being pointed at. Adding one from the catalogue, the other half of the same screen, took the same field from the same request and stored it unread, so a credential of any kind could be attached to a curated server and spent by the refresh that runs before the add returns.
Worth being plain about the reach, because it is narrower than the path beside it. The column is a foreign key, so an id naming nothing was already refused by the database, and the one entry in the catalogue is reached with each person's own Google account, whose OAuth client is registered through its own call and sent to an address pinned in code. Nothing could be delivered to an address a caller chose. What was reachable was a credential of the wrong kind being accepted and spent on behalf of somebody who never agreed to it, and a malformed id arriving as a database error rather than as a refusal.
The rule now comes from the entry: a server the deployment holds one token for takes that token, and a server answered as the person asking takes no credential when it is added, because its client arrives through the call that mints it. Both add paths ask the same question in the same words, so a credential that does not exist and one of the wrong kind are still refused identically and the endpoint cannot be used to ask which ids are real. Adding a curated server the way the admin screen does is unchanged.
Adding a curated server that is already there no longer clears the credential it points at. The column holds the OAuth client that registering one put there, and re-adding the server to change an instance host said nothing about that client, but cleared it anyway: the credential row was left behind with nothing pointing at it and nothing to revoke it, and everybody who had connected their account was told the deployment has no client registered. A re-add that names no credential now leaves the one that is there alone.
Name the private addresses an agent may live at
Refusing AGENT_COMPUTER_ALLOW_PRIVATE_HOSTS in production closed a hole and took something with
it: bring your own agent is a headline capability, a company's own agent legitimately lives at an
internal address, and the only way to reach one was to lift the floor for everything. Telling people
to set that flag is exactly the advice that made it dangerous.
AGENT_ENDPOINT_ALLOWED_HOSTS names addresses instead. A comma-separated list of hosts, each
optionally with a port: agents.internal covers any port on that host, 10.0.0.42:9000 pins that
one. A deployment sets this and leaves the floor where it is.
It is narrow on purpose:
- Agent endpoints only. Browsing is not widened. A page can steer a Bot somewhere; an operator naming an address they run is a different act from a Bot following a link to it.
- Exact matching. No wildcards and no suffixes. A list written with a
*, or written as URLs, is refused at startup with the entry named, rather than quietly never matching. - The never-allowed addresses stay never-allowed. Cloud metadata is refused before the private rule is reached, so naming it changes nothing.
- Every hop, not just the first. A named address is reachable wherever it appears and an unnamed one is refused wherever it appears, so a redirect is not a way around registration.
Unset means none, which is what every deployment has today.
A custom MCP server can only be pointed at its own token
Adding an MCP server by URL takes a credential id alongside the address, and the add is what spends it: the tool refresh that runs before the call returns decrypts whatever that id names and sends it to the address in the same request. Nothing checked which credential it was, so an administrator could name any row in the vault, including one person's connector token, and have that person's token delivered in clear text to an address of the administrator's choosing, before any Bot or grant was involved. The credentials screen lists every row's id and, for a connector token, the person it belongs to, so choosing one was a single read.
A custom server now has to be pointed at a credential of its own kind, the deployment's token for
that server. A person's connector token and the deployment's OAuth client are both refused, for the
same reason POST /api/admin/credentials already refuses to create either by hand: spending one
here uses a credential on behalf of somebody who never agreed to it. A credential that does not
exist is refused in the same words as one of the wrong kind, so the endpoint cannot be used to ask
which ids are real.
The field is unchanged for the case it exists for, and nothing changes for a server added through the admin screen, which mints a token and points at the one it just made. If a deployment has a custom server pointing at a credential of another kind, adding it again will now be refused, and the answer is to give the server its own token.
A failed action is recorded the same way it was decided
An action the policy allowed and the computer then failed is recorded twice, once for the decision and once for the outcome, so the trail can tell an action that happened from one that was permitted and did not. The second row was leaving out the command and the key that the first one carried.
A shell command that failed part-way therefore said a Bot had run something without saying what, in the row somebody reading an incident reaches for first. The same omission picked the wrong element branch, so that row also claimed the command had been looked for in the page snapshot and not found — a page element a shell call never had. A failed file write kept its path throughout and is unchanged.
Both rows now carry the same subject. Nothing about the boundary moves: the policy decided on a complete context before and after, and no action is permitted that was not permitted before.
Upgrading
A deployment that sets AGENT_COMPUTER_ALLOW_PRIVATE_HOSTS=true with NODE_ENV=production no
longer starts. Remove the line and it starts again. Nothing else needs changing, and a deployment
that never set it is unaffected.
The switch lets a Bot reach addresses inside the deployment's own network — 10.0.0.5,
192.168.1.1, 127.0.0.1:5432, a link-local address — and it does that in two places, not one:
browsing, and the endpoint a Bot may be registered against. It exists for a laptop, where the
services a Bot is asked to look at are the ones running beside it.
The reason this is a refusal rather than a warning is how a deployment came to have it. .env.example
shipped the line on, and copying that file is the ordinary way an environment gets filled in, so the
path to a hosted deployment reaching its own network was not forgetting to set something, it was
inheriting something. It now ships commented out, which means a laptop that wants the old behaviour
uncomments it and everything else arrives without it. Under any other NODE_ENV the switch works
exactly as before, with a warning at boot saying it does not travel.
The one-container image shipped with the switch on, and no longer does. It set both
AGENT_COMPUTER_ALLOW_PRIVATE_HOSTS=true and NODE_ENV=production, so the image really did run
with private-host browsing enabled. Two things that worked there stop: a Bot browsing a private
address such as an intranet page, and registering a coworker at a private endpoint like
http://10.0.0.20:8000/ag-ui. Because the image bakes in NODE_ENV=production, there is no
override — a deployment that needs either of those wants the compose setup or its own image rather
than the all-in-one. The image continues to start, and everything else in it is unchanged.
The cloud metadata addresses — 169.254.169.254, metadata.google.internal, and the IPv6 and
NAT64 spellings of them — were refused whatever this switch said, before and after. That floor has
not moved. What changed is that it is no longer the only thing left standing in a production
deployment that copied the example.
The supervisor answers on loopback, not on every address the host has
The supervisor's port was published without an interface in front of it, so it bound every address
the machine had and answered anything that could route to it. This is the service that holds the
Docker socket, so reaching it is root on the host by way of four verbs, and SUPERVISOR_TOKEN is a
shared secret rather than a network boundary. The documentation already said not to expose it
outside the deployment network; the compose file did.
It is now published on 127.0.0.1, like the computer's own port and the two Bots'. If you reach the
supervisor from another machine, that stops working and it was the thing worth stopping: put the
caller on the host, or run the server inside the compose network, where it reaches the supervisor as
supervisor:4300 and never uses the published mapping at all. SUPERVISOR_PORT still chooses the
host port.
Nothing changes for a default deployment. scripts/start.sh already reached it on localhost.
An agent's address is checked where it ends up, not only where it starts
checkAgentEndpoint decides whether this deployment will dial an address, and the request was then
handed to a fetch that followed redirects. The checked address and the dialled address were the same
address only while nobody redirected. An agent answering 307 Location: http://169.254.169.254/ put
the server on its own cloud metadata endpoint, on every run rather than once.
Every hop is now checked before it is followed, capped at three. Redirects are still followed,
because a deployment that puts its agent behind one has done nothing wrong, and each destination has
to be somewhere registering it directly would have been allowed to reach. The stored address is
checked before it is dialled too, which is the one address a check reading only Location headers
never looked at.
A hop that leaves the host the request was authorised for arrives with nothing that proves who we are. The customer's key was given to us for their host, and this deployment's signed run assertion names the Bot and the person and can spend their grants, so both stop at that boundary and do not come back if the chain returns. A scheme upgrade to the same host and port keeps them.
Refusals are now on the audit trail as agent.dial_refused, with the address and the reason. A
refused run already told the person what happened; nothing told the deployment, and an agent that
has quietly started redirecting somewhere it should not is worth being able to count.
A connector says which of its granted tools it no longer offers
A grant names serverId/toolName, and a Bot is told about a tool only when the grant and the vendor's
current tool list agree — so a grant on a tool the vendor has stopped listing reaches no model. That
is a property of what the vendor advertises today rather than of the grant, and nothing said it was
happening: the plugins page built its grant list from the advertised tools, so such a grant appeared
nowhere at all. The one screen an administrator reads to answer "what may this Bot do" was quietly
leaving some of the answer out.
A connector's page now has a "Held but not offered" section listing them, with how many Bots hold each, and a refresh that leaves any behind writes an audit row naming the refs and the Bots. The grants themselves are untouched: a tool the vendor starts listing again is offered again, and revoking stays a decision somebody makes rather than a side effect of a vendor's bad afternoon.
Nothing changes for a connector whose grants all match its tool list, which is the normal case — the section is not drawn and no row is written.
Opening a new chat no longer logs a server error
A thread id is minted before the thread exists — the platform creates it on the first run — so reading
history on a brand-new conversation asks about a thread nothing has heard of yet. The platform answered
404, the runtime reported that as 500 Failed to fetch thread messages, and every new chat left one in
the log with a stack trace behind it. Nothing was visibly broken, because the browser only reads a
history it got a 200 for; what was missing was any way to tell a thread that does not exist yet from a
history store that is down.
A thread the platform does not have now reads as having no messages. A 404 and only a 404: a 500 stays a 500, because an outage answered with an empty history would tell the browser the conversation is gone and invite somebody to start it over.
Reconnecting a live screen no longer stops the screen you just reconnected
A Bot's screen allows one viewer, and opening a second /stream replaces the first. The replaced
socket is left open, because it belongs to a client that may still be using it, so on an ordinary
reconnect, where the browser opens the new connection before dropping the old one, the old socket
closed after the new one was already casting. Closing it stopped the session's viewer without asking
whether the closing socket was the one casting, so it stopped the replacement.
Both halves were silent. The screen stopped updating, and anything typed afterwards was dropped without a word, because the input path looks for a viewer before it looks for anything it can report.
A close now stops casting only when the socket closing is the one that was casting.
A sidebar channel row can be pinned or deleted
Right-click on a channel in the sidebar and a menu opens with two entries: Pin channel and Delete channel.
Pin is held per member rather than per channel, so pinning one holds it at the top of your own roster — newest first among pinned channels — and leaves every other member's roster unaffected.
Delete is confirmed in a dialog first, and it is soft. The channel disappears from every member's
roster and from a direct fetch of it, while the row, its transcript, and its Intelligence thread all
survive. That disappearance is live, not just on next load: every member's open tabs drop the row as
the delete lands, and a tab parked on the channel itself is sent home. The deletion is audited as its
own channel.deleted row. A channel the deployment package defines is refused, with the reason
named. Recovery today is clearing channels.deleted_at in the database directly; there is no restore
control in the product.
The deployment gains two nullable columns, via migration 0016.
An MCP server address that points inside the deployment is refused in three more spellings
Adding an MCP server by URL is checked before the address is stored, because that form is otherwise a way to point the deployment at its own network. The check compared the literal hostname, and three spellings of an address it means to refuse were getting through.
A trailing dot is the root-anchored form of the same name and reaches the same place, but it changed
the string enough that every rule missed it, so https://localhost./, https://printer.local./ and
https://metadata.google.internal./ were all accepted. kubernetes.default.svc, which is how a
service is addressed from inside a cluster, carries dots and none of the listed suffixes, so it read
as an ordinary vendor name.
The third is worth acting on rather than just noting. A credential typed into the address itself,
https://user:[email protected]/mcp, was accepted, and the address is stored and named in the
trail as given. Audit redaction works on field names and url is not one of the sensitive ones, so
the token was written to mcp_servers and to an audit row in clear text. The trail is append-only by
design, so that row cannot be deleted afterwards: a deployment where somebody has done this should
treat that credential as disclosed and rotate it. The address field now refuses a credential and
points at the token field instead.
A deployment that reaches its MCP servers by ordinary vendor hostnames sees no difference.
One unreadable turn no longer takes a whole conversation down
Restoring a thread cast whatever the history store held straight to messages and handed it to the
transcript. A turn stored in a different shape — a tool call written {id, name, args} rather than
AG-UI's {id, type: "function", function: …}, which interrupted runs have produced — reached a
renderer that read toolCall.function.arguments and threw, so a single bad turn made the whole
conversation unopenable rather than that one message unreadable.
Each stored turn is now parsed against the schema AG-UI ships, and one that does not parse is left out instead of being drawn. Checked where history enters the app rather than in one renderer, so every surface that reads a transcript is covered by the same check.
A turn that is left out is said out loud. The conversation shows a line above it naming how many earlier messages could not be read, because a record people read back must not have a hole in it that nothing accounts for — a turn that silently disappears reads as one that was never sent. Multimodal content and every well-formed tool call are unaffected, and a history that cannot be read at all still opens the composer rather than blocking it.
Refreshing no longer flashes white before the theme arrives
A person with the dark theme selected saw a white frame on every reload. The stored preference was read early enough, but it was applied one paint too late: the browser had already drawn a frame against the light palette by the time the app got to it. The document now decides its theme before anything is drawn.
The browser was also drawing its own surfaces — scrollbars, form controls, the overscroll area — light under a dark app, for the whole session rather than for a frame. Both themes now declare which one they are, so those match too.
No configuration changes and nothing is stored differently; a deployment that was already on the light theme sees no difference at all.
start.sh refuses a port that answers but is not OpenBot
The startup checks asked whether a port answered, and treated that as proof the port belonged to this
stack. Those are not the same claim. Any single-page app serves its index.html for every path it does
not recognise, so an unrelated dashboard on a default port answers 200 to /api/capabilities as
readily as this server does.
The cost was not a wrong answer, it was a wrong answer three stages later. require_free_or_ours
reported "already up", so the server was never started; wait_for then printed a green
"server ready"; and the run failed at stage 3 inside json.loads, parsing that stranger's HTML. The
error names char 0, which reads like an empty response rather than a <, so the visible symptom
pointed nowhere near the port.
Each surface is now asked for something only it can produce: a licenseStatus field for the server,
its own <title> for the app, /health for the compose services. When a check gives up it says
whether the process failed to start or the port belongs to something else.
The root cause was in .env.example, and is fixed there too. The server reads PORT, this script
reads SERVER_PORT, docs/configuration.md documents SERVER_PORT as the setting, and only PORT
shipped. Moving the server by editing that one line left the script still looking at 3001. Both names
are now present, next to each other, saying they have to agree.
A run may now stop where it used to continue. That is the point: it stops at the port that is wrong, naming it, rather than several steps later on a parse error.
docker compose up -d configures the same stack scripts/start.sh does
SUPERVISOR_TOKEN and COMPUTER_TOKEN defaulted to the empty string in docker-compose.yml, so
which stack you got depended on how you brought it up. scripts/start.sh resolves both to their
openbot-dev-* defaults and exports them before calling compose. A plain docker compose up -d —
which this project's own shutdown notes tell you to use — passed an empty string instead.
agent-computer refuses to start without one, so that half failed loudly. The supervisor half was
the quiet one: the server kept the token it started with while the supervisor held an empty string,
and every call between them was refused at the door.
Both now carry the same defaults start.sh applies, as COMPUTER_IMAGE already did two lines down.
A value set in .env still wins, and a deployment should set one.
0.0.4
A click citing a ref this deployment cannot resolve is refused
A Bot acts on a page by citing a ref from a snapshot, and the server turns that ref back into the element before the boundary judges it. When the lookup failed, the action went ahead anyway with the element half of the decision left empty — so a rule like "never click anything named submit" was not declining to match, it was never shown the element, the shipped default permitted, and the click landed on whatever that ref points at now.
The computer's own staleness check does not cover this. It compares a citation against its own counter, so it catches the cases where the two disagree; the case that bites is the one where the computer is content and only this deployment is out of step, which is what restarting a computer under a stored snapshot leaves behind. The same click on the same button under the same policy was refused before a redeploy and carried out after it.
A citation this server holds a snapshot for and cannot resolve is now refused, and the person is told to take a fresh snapshot. Actions that name no element — scrolling, a page-level keypress, a shell call, a file read — are untouched, and a computer this deployment holds no snapshot for still has its citation forwarded, because there it is the only party that can answer. The refusal is raised after the decision row is written, so an action somebody tried to take still appears on the trail.
A deployment may see refusals it did not see before. That is the point: those are the actions that were being carried out without the boundary seeing what they touched. A Bot that meets one takes a fresh snapshot and continues.
A package ships its skills, so tool selection works on a clone
Tool selection narrows a Bot's tools to the ones its matching skills declare, and a deployment starts
with no skills at all. There was no skills.yaml, nothing seeded any, and nothing ever created one
— so on every fresh clone there was nothing to match against and the narrowing never switched on.
Left to a screen it would have stayed that way until somebody sat down and mapped tools to skills by
hand, in each deployment, again after each new connector.
A tenant package may now carry skills.yaml. Each skill has a slug, a title, a summary, its
instructions, and the serverId/toolName refs it needs. They are seeded on boot as deployment
skills, everybody sees them in the / menu, and connecting a connector is the only step left.
skills.yaml is optional, so every existing package loads unchanged and ships no skills. A package
may declare tools for a connector nobody has added: an unknown ref sits inert, because the offer is
still intersected with the Bot's grants. Naming a tool in a package grants nothing, exactly as
before.
A skill somebody wrote in the deployment keeps its name. If a package ships a slug a person already took, theirs stands, the package loses that one, and the deployment starts — a name is not worth refusing to boot over.
The example package ships four: /find-a-document, /whats-changed, /who-owns-this and
/check-a-claim.
The tools a skill needs can be picked where the skill is written
A package's skills arrive with their tools declared. A skill somebody writes here could not: the
tools field existed on the save endpoint and on no screen, so a skill written in the product declared
nothing, and the only way to change that was to call the API by hand. Writing or editing a skill now
lists the tools of every connected server, grouped by server, with the ones that change something
marked.
Picking a tool here is not granting it. The offer is still intersected with what the Bot was granted, so a skill naming a tool its Bot does not hold selects the skill and loads nothing — which is why anybody may write a skill while connecting a server stays an administrator's decision. The screen says so, next to the choice.
A tool the skill names that no connected server offers is shown too, under its own heading, rather than left out. A package ships skills declaring tools for connectors nobody has added yet, and a skill outlives the server it was written against, so a screen that drew only what matched was stating part of the declaration as though it were all of it.
0.0.3
A Bot is offered the tools its message needs, not every tool it holds
A model chooses the right tool reliably out of about ten and unreliably out of thirty, and it fails quietly: it calls a plausible neighbour, or calls nothing and answers from what it already knew. Two connectors is enough to cross that line, so a Bot holding more than twelve tools is now offered, for each run, the tools of the skills that match the message.
Skills already declare the tools they need. That declaration is now what the offer is built from: the deployment asks its own model which skills a message needs, and the Bot gets those skills' tools plus every granted tool no skill has claimed. Nothing here can widen a Bot: the offer is intersected with the grants, so naming a tool in a skill still grants nobody anything.
Nothing changes for a deployment that has not declared tools on any skill, or whose Bots hold twelve tools or fewer. Those Bots are built exactly as before, with no extra model call.
There is a new audit event, mcp.tools_discovered, written before the run. It says how many tools
were offered out of how many granted, and why: the skills chosen, or that nothing was declared, or
that the choice could not be made. It answers "why did it call that", and the harder question, "why
did it not call anything at all" — which until now left no trace.
The intent router works again behind a gateway
OPENAI_BASE_URL is documented ending in /v1, and the router appended /v1/chat/completions to
it, so every call went to /v1/v1/chat/completions and 404'd. The router reads a failure as "not
sure" and falls back to the default coworker, so on any deployment that set the variable — a
gateway, a proxy, a self-hosted model, which is the only reason to set it — untagged messages
silently stopped being routed and nothing said why. The version segment is now added only when the
configured URL does not already carry one.
0.0.2
Upgrading
AGENT_TOOL_TOKEN is generated for you on a laptop. scripts/start.sh mints one and writes it to
.env, the way it already did for MANAGED_AGENT_TOKEN. Without it no Bot could call a tool back
through the deployment, which is the correct default for a deployment and made every MCP tool dead
on arrival on a fresh clone. A value already set is kept, and .env.example still ships it empty,
so a deployment not using start.sh is unchanged and still fails closed.
start.sh also stops skipping work for services that are already answering. A Bot container is now
handed to docker compose on every run and the server is restarted when this run minted a secret,
because answering says a process is alive and not that it still agrees with the deployment. The cost
is that a run which rebuilds an image recreates the Bot containers, about five seconds; supervisor
already behaved this way.
Two configurations now refuse to start:
- A provider configured with no
INITIAL_ADMIN_EMAILS. Set it to at least one address. - No provider at all and no
OPENBOT_SINGLE_USER=true. Configure a provider, or set that to say you meant a deployment where every visitor is one administrator. This no longer depends onNODE_ENV, which is unset by default and so let exactly the dangerous case through. A deployment already running open needs the line added before it will start again.
Registering an OpenID Connect provider needs every host in its discovery document in
TRUSTED_ORIGINS, not only the issuer. Better Auth 1.7 checks each endpoint it finds, so a Google
issuer also needs oauth2.googleapis.com and openidconnect.googleapis.com. Registration is
refused with the untrusted host named.
A Bot id may now contain only letters, digits, hyphen and underscore, and must start with a letter or
digit. The same rule container and volume names have always followed. A deployment whose
COMPUTER_BOT_ID breaks it refuses to start and says so, rather than answering 400 to everything.
AUDIT_RETENTION_DAYS is new and unset, which keeps the audit trail forever, as before. Set it to a
whole number of days to have old rows removed.
The local document index and the old connector tables are dropped by migration. documents,
chunks, document_acls and the four connector-bookkeeping tables are removed and their rows go
with them; this cannot be rolled back. A deployment that had been syncing into the local index loses
that copy, which is the point: answering now goes through a live system's own search.
An MCP server pointed at a credential that no longer exists loses the pointer. mcp_servers
now names its credential with a real foreign key, where the column was text against a uuid
primary key with nothing checking it — so a deployment is allowed to be holding a pointer to a vault
row that was deleted underneath it, and the screens read as though the server were still configured.
The migration clears those before adding the key, because it cannot add it otherwise. If this
happens, that connector correctly reports having no credential and an administrator registers it
again; nothing else is affected, and a deployment with no such pointer sees nothing.
The old Google Drive connector is gone, and it is not the new one renamed. It configured a
service account with domain impersonation and had the worker sync documents into a local pgvector
index guarded by our own ACL rows, so every person got the same answer computed from what one
credential could see, and revoking somebody's access left a cached copy of their documents behind.
/admin/connectors and its two screens, the connector catalogue and admin service, the sync
persistence and the worker's connector runner have all been removed. A deployment that was syncing
this way stops syncing and should enable the new connector at /admin/plugins/google-drive, where
each person connects their own account.
knowledge.yaml is still parsed and still refused when malformed, because it is part of the
deployment-package contract. Its sources: are now read by nothing.
MANAGED_AGENT_AG_UI_URL is no longer required to start. The one-container image does not carry a
Bot, so requiring it registered the shipped Risk Analyst against a host that was not there and every
conversation with it failed. Leave it unset for that image. A laptop scripts/start.sh still points
it at agent-langgraph. A URL with no MANAGED_AGENT_TOKEN still refuses to start; a leftover
token with no URL is ignored.
A .env copied from an older .env.example still has MANAGED_AGENT_AG_UI_URL=http://localhost:4201/ag-ui.
Unset it before docker run --env-file .env, or the coworker comes back.
The built-in Bot refuses to start without OPENAI_API_KEY. It used to start, report healthy, and
then fail every conversation, so a missing key looked like a working deployment. The LangGraph Bot
already refused the same way.
Sessions survive and nobody signs in again.
Changed
- This deployment does not search documents itself. A Bot answers from a live system by calling
that system's own search as the person asking, so the vendor decides what they may see and there is
no second copy of anybody's documents here to keep in step, to secure, or to leave behind when
somebody is removed. The local index that was being filled —
documents,chunksanddocument_acls— and the connector that filled it have both been dropped. Retrieval over a copy of a customer's corpus is not a thing OpenBot does.
Added
A skill can say which tools it needs.
POST /api/plugins/skillstakes atoolslist ofserverId/toolNamereferences, stored against the skill and returned with it. This is the unit tool retrieval will select over: a model picks a skill from its summary, and the skill says what to load. It grants nothing. A skill naming a tool a Bot was never granted still cannot call it, which is what keeps writing a skill open to anybody rather than to administrators only. A reference naming no tool this deployment has seen is refused when the skill is saved, so a typo is an error where it was written. Leaving the field out of a save leaves whatever was declared before, so nothing that predates it clears a declaration; sending an empty list is how a skill stops asking. Nothing consumes these yet — selection is the next piece, and until it lands a deployment behaves exactly as before.A message with no
@goes to the coworker it is for. Typing without naming anyone used to reach the default coworker; to get a specialist you had to@them. Now an untagged message is routed to the coworker whose purpose matches it, chosen against each coworker's own description by the deployment's own model, before the channel is pinned. It is named, not silent: the channel header is the coworker it went to, and achannel.routedrow records the choice, the reason, and the candidates it chose between (never the message itself).@still wins as an explicit override and skips routing entirely. If the router is uncertain or unreachable, it falls back to the same default the composer always used, and says so, rather than misroute or drop.A Bot can answer from Google Drive, as the person asking. Ask a Bot a question whose answer is in a document and it answers from the live file rather than from an index, citing a link that opens it. A Bot granted these tools reads Drive on the asker's own grant, so two people asking the same question get the answers their own accounts can see, and neither sees the other's documents. Read-only: the scope requested is
drive.readonly, so a write is refused by Google before this deployment has to. Nothing is cached — the refresh token is stored and an access token is minted per call, so revoking access at Google takes effect on the next one rather than when a cache expires.Setting it up takes two people and neither can do the other's half. An administrator registers a Google Cloud OAuth client and enables the connector at
/admin/plugins/google-drive; each person then connects their own account, and there is deliberately no endpoint for an administrator to connect one on somebody's behalf. The redirect URI has to match what is registered character for character, and the connector page states the exact string to paste, because a mismatch fails at Google with a message that never mentions OpenBot. See docs/plugins/google-drive.md for the whole setup and for what each failure means.Disconnecting is not built yet. The account page says so and points at Google's own third-party access settings, which is what withdraws it today.
Each tool a connector offers has its own screen, at
/admin/plugins/<connector>/tools/<tool>, with a switch per Bot. The connector page previously drew a button per Bot inside every tool row, which is a control per Bot per tool stacked in one list, and grew without bound as Bots were added.Connected accounts, at
/settings/connected-accounts. What a Bot may read as you, and the scope the vendor actually granted rather than the one that was asked for.A tool result that found nothing says so. An empty result used to reach the model as an empty string, which reads as "the tool had nothing to say" rather than "there is nothing there" — and a model closes that gap from memory, which for a knowledge connector is the failure worth preventing.
The shipped Knowledge Bot answers from the tools it has. Its instructions in
examples/fintechtold it to say no source was connected, which was honest when none could be: the connector this replaces had been removed and nothing had taken its place. With a connector granted it became the opposite of honest — the Bot called a tool, was handed a file listing, and said it had no access anyway. It now reports what its tools return, says so plainly when it has no tool or a tool reports a problem, and does neither of the two things worth forbidding: answering from its own memory as though it came from a source, or claiming to lack access to something a tool has just returned. A deployment with its own tenant package is unaffected.mcp.call_failed. A call this deployment permitted and the vendor did not complete now leaves a row of its own, carrying the vendor's own sentence.mcp.call_succeededwas written before the network call rather than after, so a call that died at the vendor recorded success and the Admin page agreed with it.Releases are cut by a workflow, not by hand.
Create release PRbumps the version and promotes## Unreleasedto a numbered section; merging the pull request it opens is what publishes. Merging builds and pushes one image toghcr.io/copilotkit/openbot, signs a build provenance attestation for its digest, tags the commit and creates the GitHub Release withcontainer-images.jsonso a deployment can name an exact digest rather than a tag somebody could move. See docs/releasing.md.CI now runs the thing it ships. Two checks were added.
migrationsrefuses a schema change with no migration written for it, and a snapshot that has drifted from the schema.imagebuilds the container, boots it with embedded PostgreSQL, and fails if it does not answer or if a supervised service is respawning. A singleverifycheck covers every job, so branch protection needs one entry. The same checks run again against the release commit when a release is published, so they gate the release rather than the proposal for one.Sign in with Google, Microsoft or Okta. Any one of them turns sign-in on; configure several and the sign-in screen offers each, on matching buttons carrying each provider's own mark.
INITIAL_ADMIN_EMAILSsays who is an administrator. It is required whenever a provider is configured, because nothing else grants the role, and it is now a floor rather than a one-off: an address it names is made an administrator at every sign-in, so adding somebody to the list works even after they have already signed in.SAML and OpenID Connect, registered while running.
/admin/identity-providerstakes the metadata a company's identity team supplies and registers their own IdP. Somebody then types their email address on the sign-in screen and the domain decides which provider they are sent to, so a company mid-merger can run two. Registering, changing or removing one is administrator-only, which the upstream plugin does not require: it guards those routes with a session, and anybody who could reach them could register a provider for a domain and mint themselves colleagues.A People screen.
/admin/peoplelists everybody who has signed in, with the provider they came through and when they were last here, and lets an administrator promote, demote, or remove somebody. Removing ends the session they are using and stops the next sign-in, keyed on the address so signing in again through the provider does not quietly create a new account. Every change is on the audit trail. Somebody named inINITIAL_ADMIN_EMAILScannot be demoted or removed here, and nobody can do either to themselves.One container that runs the whole thing. The root
Dockerfilebuilds an image carrying the app, the API, a Bot computer, and optionally PostgreSQL, supervised together. PointDATABASE_URLat a database you already run and the built-in one never starts; leave it unset and the container is self-contained. See docs/deployment.md for the measured minimum sizes and the platforms it has been run on.Bots can run commands.
computer_run_commandruns a command in the Bot's/workspace, so a Bot can install a tool, unpack what it downloaded, or run what it was asked to run instead of only driving a browser. Governed like every other action: the policy decides, the audit row is written first, and a rule can refuse a shell outright withintent == "run_command"or refuse particular commands. The command is recorded; its output is not.The audit trail shows the command. A command row names what ran, the way a file row names the path, rather than reporting an element it was never about.
COMPUTER_SANDBOX=onturns on Chromium's own sandbox where the host permits user namespaces. Which way it went is printed at start-up either way.New chat. The direct Bot chat has a button that starts a fresh conversation, which it had no way to do before: the thread was minted once and remembered for that Bot forever, so the only way out of a conversation was to clear the browser's storage by hand.
You can watch what a Bot is doing, not only what it is looking at. The screen answered half the question: a Bot spending two minutes in a terminal showed a blank browser and one grey line per command, with the output nowhere. A command line in the transcript now opens to show what it printed, its exit code, and whether it was cut short or stopped. Beside the screen there is an Activity tab carrying every command, file read, file write and listing as they happen, newest first, with a count on the tab so a Bot working away from the browser is visible without switching to it. A saved file shows its path and size, never its contents. This is a live view of the open conversation; the record is still the audit trail.
Sign-in is on the audit trail. Rows for signing in, for being refused, and for the configured administrator list granting somebody the role. Two questions had no answer before: who granted themselves administrator by editing
INITIAL_ADMIN_EMAILS, and whether somebody just removed had ever been here, since removing them deletes the sessions that were the only evidence. A trail that is unavailable never blocks a sign-in.
Fixed
A ref could resolve against a page from a computer that no longer existed. The generation a computer stamps on a snapshot is unique only within one run of it, so a replaced container counts from one again and a ref the model is still holding matches a row nothing has overwritten. The policy then decides on an element from a dead page, and the audit row names it. Wiping a computer cleared the row for that reason and was the only thing that did; replacing one whose image changed did not, and the server was never told. A snapshot now carries which run of the computer took it, refs from an earlier run resolve to nothing, and the first snapshot of a new run replaces the old row however low its generation.
A migration stamped in the future silently swallowed the next one. Drizzle runs a migration only when its journal timestamp is later than the newest one the database has recorded, so a migration stamped ahead of real time raises that ceiling and every migration written after it is skipped until the clock catches up.
drizzle-kit migratereports success the whole time. One migration was hand-written a day into the future and did exactly that to the next one to arrive: the table was never created, and the only sign was an integration test failing on a relation that did not exist. The timestamps are corrected, an older inversion between two earlier migrations is corrected with them, and the journal is now checked by a test, because nothing else in the build would notice. If you ran a build between these, your database has the wrong ceiling recorded and will skip the next migration. Repair it withupdate drizzle.__drizzle_migrations set created_at = 1787359000000 where created_at = 1787444747113;or start from a fresh database, where migrations all run in one pass and ordering cannot bite.Every Bot ran a model two generations old, and it was costing tool calls. The example package shipped
gpt-4.1as the default for every built-in Bot. Asked to open a page behind a sign-in, those Bots answered "would you like me to prompt you to sign in?" and called nothing, three times out of three, while the prompt forbids that sentence in as many words. Ongpt-5.6-terrathe same question produces the tool call first try, so the package now runsgpt-5.6-terra. It is a default, not a commitment:model.yamlstill decides.The Bots that answer over AG-UI stay on
gpt-5.5, each for its own measured reason. The framework Bot answers nothing at all ongpt-5.6-*through the Responses API —RUN_STARTED, thenRUN_FINISHED, no text — and the hand-written one cannot use function tools on/v1/chat/completionswith a 5.6 model unless reasoning is turned off, which is the wrong trade for a Bot whose job includes deciding when to ask a person for help. It refuses to start on such a model now rather than failing one silent tool call at a time. Where a 5.6 model is set deliberately, the Responses API is switched on for it automatically, because a deployment that set the model and did not know about that switch got a Bot which started, looked healthy, and failed on its first tool call.A Bot browsed to a vendor this deployment already connects to. A Bot holding no grants was told nothing about connectors at all, so it treated a connected vendor as an ordinary website: asked about Google Drive it opened
drive.google.com, met a sign-in page, and asked the person to sign in to an account the deployment had already connected. Every Bot is now told which vendors exist here, held or not, and says plainly which one it has not been granted rather than reaching for the browser.A conversation was destroyed by a declined take-the-wheel. A Bot that asks for help with a sign-in and never gets it left a tool call nothing ever answered, and every later turn in that thread failed at the provider. This was fixed once for the framework Bot and not for the Bot in the box, which is the one behind the Browser Bot, so it went on happening where most people would meet it. Both now answer their own unanswered calls with the truth rather than a fake success.
A Bot refused because a person had the wheel was told its refs were stale. The computer flags a takeover, the surface branches on that flag, and the flag did not survive the server, so a Bot was sent back round the same action against the person who had just taken the browser. Reported and fixed by @beardthelion.
A person could not take the wheel unless the Bot offered it. The button appeared only after a Bot called for help, so the control a person needs depended on the Bot getting one instruction right, and when it did not there was nothing to press. It is there whenever the Bot is driving now. The Bot asking for help is still its own row, with its reason.
The first message of a new channel could be lost. A new channel's thread does not exist until its first run, so the join that restores history had nothing to settle against; the message was sent anyway after a deadline, while that join was still in flight, and the join finishing replaced it with the thread's messages, which were none. The deadline now ends the join and waits for it, so nothing is left in flight to overwrite anything. The transcript also says it is loading rather than showing an empty conversation, and the thinking line is visible for the first time: a CSS rule blanked the colour a gradient was built from, so the glyphs were painted with nothing. Reported and fixed by @zopeVaibhav.
The in-memory snapshot store disagreed with the table. The database only ever moves a snapshot forward; the in-memory one, which is what a test reaches for when it has no database, took whatever arrived last. A test could therefore prove a boundary property that is false in a deployment. Reported by @beardthelion, fixed by @NathanTarbert.
A computer that had opened nothing still reserved a browser-sized frame. That put a placeholder the height of a browser window into the middle of a conversation, above an answer that never involved the browser.
A Bot named after a deployment route was served without its guard. The computer router steps aside for
/policyand/fleet, which are its own paths and not about a Bot, because Hono matches/*against zero segments and a single-segment path arrives as a Bot id. It stepped aside on the name alone, so it covered everything under those names too:/policy/statusis/:botId/statuswith a Bot calledpolicy, and for that whole subtree the access check was never called at all. The guard now steps aside only for the deployment path itself, and a Bot may no longer be named after one: a package declaring it is refused, and a deployment that already holds such a Bot refuses to start and names it rather than serving it. Reported and fixed by @beardthelion.Upgrading never reached a Bot's computer. A computer is a container the supervisor makes, and it was reused by name whatever image it was built from, so once a Bot had one, rebuilding the image moved the tag and the container went on running the old one indefinitely with nothing to say so.
docker compose downdoes not touch these either, because compose did not make them, so even a full teardown left them behind. That is worse than stale code: the computer is the browser, the workspace and the confinement around both, so a fix to any of them silently did not apply. A computer built from a different image is now replaced on next use. Its profile and its workspace are volumes and are kept, so a Bot comes back on the new image still signed in to what it was signed in to, with its files where it left them.The audit trail could be erased with one statement. It is append-only because a database trigger refuses updates and deletes, and that trigger is row-level, so
TRUNCATEnever reached it: anything holdingDATABASE_URLcould empty the table and nothing raised. That is the case the guarantee exists for, since it is enforced in the database precisely because the application is not the only thing that reaches the table. A statement-level trigger now refuses a truncate, and it answers before the retention setting is read, so declaring a retention window no longer permits one either. Retention itself is unchanged: rows older than the window are still removed, and recent ones are still refused. The connection the application uses is the database owner in the shipped compose file, and an owner can still disable or drop a trigger; closing that needs a role withINSERTandSELECTonly, which is a separate change. Reported by @beardthelion, who also named the failure mode of the obvious fix and saved it from shipping as one.A declined take-the-wheel destroyed the conversation. A Bot that asks for help with a sign-in and never gets it left an assistant message holding a tool call that nothing ever answered, and every later turn in that thread failed at the provider. Declining once meant nothing you typed afterwards got an answer, with no way back but a new chat. Unanswered calls are now answered when the history is rebuilt, with the truth rather than a fake success: no result came, the run has ended, carry on without it and say what could not be done.
The audit trail could not say why a conversation went where it did. It recorded the router's choice and recorded nothing at all when a person named a coworker with
@, which is indistinguishable from a row that failed to write. A mention is now recorded too, as the person's own choice, without asking the model a question they had already answered. The audit page names the coworker and separates the three cases: chosen by the person, matched by the router, or the default because nothing matched.A Bot with half a connector sent people to a sign-in box. Granted a vendor's search but not its read, it found the document, could not read it, and opened the vendor's website to try, where it met a sign-in wall and asked the person to take the wheel. They already had access; the missing thing was the Bot's grant, and nothing said so. A gap in what a Bot holds is now reported as a gap: it names the capability it would need and says an administrator can grant it on that connector.
Answers arrived with no sign of where they came from. Asked a compliance question, a Bot replied with a filing obligation, a dollar threshold, a deadline and a retention period, and the audit trail for that turn held one row: the routing decision. A confident unsourced answer is indistinguishable from a confident wrong one. Every Bot is now told to cite what it read and to say plainly when an answer is from its own knowledge instead. It is told this by the deployment rather than per agent, so it cannot be missing from the next Bot somebody adds, and it is explicitly not an instruction to go hunting for a source.
A Bot browsed to a vendor it already had tools for. Granted Google Drive, asked what was in a document, it opened
drive.google.comin its own browser, met a sign-in page that browser can never satisfy, and asked the person to sign in to an account they had already connected. A tool array says a tool exists; it does not say the tool is the way to reach that system, and it was competing with a page of prose about the browser that mentions connectors nowhere. A Bot is now told which systems it holds tools for, generated from its grants and placed before that prose, so enabling a connector changes what the Bot is told on its next run.A question went to a coworker that had no way to answer it. Routing read the sentence somebody wrote about what a coworker is for, which is not the same as what it can reach, so a question about a Drive document went to the one whose description says "company knowledge" and which held no Drive grants. Candidates now carry the systems they hold tools for. Purpose still decides first: a specialist with no connectors is still right for a question about its specialism.
A deny rule about submitting a form was walked around by typing.
computer_typetakes asubmitflag that presses Enter once the text is in, and the policy never saw a key, so a rule refused at the button and at the keypress let the third route through. Both shipped copies of that rule name both tools now, the key reaches the policy, and the audit row carries it — without it a row said a field was filled in rather than that a form was sent.A Bot refused at the door left no trace. A callback that could not prove which Bot it was returned 401 and wrote nothing, so a Bot holding a token the deployment no longer accepted had every call refused, returned nothing to its own model, and the model told the person there were no results. A false negative delivered as an answer, with the audit trail agreeing nothing had happened. Recorded now as
mcp.callback_refused, naming the tool and the reason but no Bot or actor, since both arrive in the credential that just failed to verify.An unanswered request for the wheel followed a Bot around. Control belongs to a Bot's computer rather than to a conversation, so a request nobody took sat there indefinitely and every later conversation with that Bot showed a live prompt for work it was not doing, captioned with a reason written for somebody else. An unanswered ask now stops being shown after ten minutes and its reason goes with it. A person actually holding the wheel is never timed out.
/admin/computerslisted nothing, ever. Admin addressed the fleet through a per-Bot route with a placeholder id, which stopped working when that route began checking whether the caller may act as the Bot in the path. The screen renders nothing while the list is null, so a deployment with two running computers looked like one with none. The fleet has a route of its own, still administrator-only.Every shipped component was recorded twice on a first start. Two browsers announcing at once is ordinary and the insert was already safe for it; the answer was not, so the loser of that race named every component anyway and the caller wrote an audit row per name.
A Bot could reach the deployment's own network by writing the address a different way. The guard refused
169.254.169.254and the private ranges as usually written, but not the same addresses spelled as an IPv6-mapped or NAT64 form, an integer, or with a trailing dot, so a Bot talked into fetching one still reached cloud metadata or an internal host. The address is canonicalised before it is checked now, the mapped form of0.0.0.0(which reaches every local port) is refused, and the container credential endpoints a hosted deployment must never expose — ECS and Fargate's169.254.170.2, Alibaba's100.100.100.200— are refused even when the private-host opt-in is on. The same guard backs agent registration, so it is closed there too.The supervisor could adopt a container it did not create. When starting a Bot's computer hit a name already taken, it started whatever held the name and handed it the deployment's computer token, so on a Docker host shared with anything else it could drive a stranger's container as a Bot's. It now refuses a container that does not carry its own namespace label, read from the container rather than inferred, so a second deployment on the same host is never adopted.
Removing somebody left the credentials they had granted this deployment sitting in the vault. Removing them from the People screen ended their sessions and stopped the next sign-in, and left the refresh token behind, unrevoked. They could not use it — the account comes from a session they no longer get — but "we removed their access" was not true of the token, which for a connector read as the person asking is the part that matters. Removing somebody now retires it, and each retirement is on the audit trail as
mcp.account_disconnected. Deleting a person's row used to be worse, because it took the connection record with it and left the credential reachable by nothing at all; those are found and retired too. This stops the deployment holding a usable secret. It does not withdraw the grant at the vendor, which needs revoking there until disconnect ships, and the audit row says which of the two happened rather than implying both.The one-container image registered a coworker it could not run.
MANAGED_AGENT_AG_UI_URLdefaulted tolocalhost:4201and was required, so Risk Analyst appeared on the roster and every conversation with it failed. The URL is optional; the package omits that coworker when it is unset.scripts/start.shstill points it atagent-langgraphon a laptop.A boundary rule applied on one server out of N. The policy is read from memory on every action, which is right, but memory was only ever filled at boot. An administrator's new deny rule was enforced by whichever process served the request and roughly one action in N went through it, while the admin screen reported success because the row really was saved and the audit trail agreed because it records the boundary each process started with. Both honest, and both describing something other than what the fleet was enforcing. A write now announces on Postgres in the same transaction and every server re-reads, including on reconnect, so a server that was down when the rule changed catches up rather than waiting for a restart. Reset travels the same way.
A ref resolved on one replica and nowhere else. The gateway turns the opaque ref in a click into the element it points at, and that mapping lived in a
Mapin the process that took the snapshot. On any other replica the ref resolved to nothing, so a deny rule written about the element did not match and the click went through, recorded as allowed with no rule. It is in Postgres now, keyed on the generation the computer stamped, so a ref from a superseded page still resolves to nothing.Anybody signed in could act as anybody's Bot. The Bot id travels in the path and the acting routes checked only that somebody was signed in, so a signed-in person could drive another person's private Bot, reset its browser, read its screen and fire its granted tools. Every route under a Bot id now asks the store the same question the roster already asks, and a Bot that does not exist and one belonging to somebody else answer identically.
The computer fleet listing was open to any signed-in person. It ignores its
:botIdand returns every Bot's machine, so it told anybody who could reach it every Bot id in the deployment and whether each was running, private coworkers included. Administrator-only now.A Bot id could name a directory outside the profiles volume. The id arrives as a URL segment or a header, was joined onto a filesystem path, and
resetdeletes that path recursively as root, so../../tmp/somethingdeleted it. Refused at the request boundary and again where the path is built.A mistyped deny rule permitted instead of refusing. A rule that parsed and evaluated but answered with something other than true or false was neither a match nor an error, so
deny: ["Submit order"]— what somebody writes who reads the list as labels — let the action through with nothing logged, while the rule sat on the Boundaries page looking as though it were in force. Any non-boolean answer is now a broken rule and takes the existing fail-closed path.Rotating a Bot's key left the old one live. Editing a key wrote a new vault row and repointed the Bot at it, leaving the previous credential decryptable and still valid with nothing listing it, so rotation did not do the one thing rotation is for. Deleting a Bot left its key live too. Both revoke now.
Nothing recorded what changed about a Bot. Ten mutating routes wrote one audit row between them and there was no event type for any of the other nine. A Bot's endpoint is where conversation content is sent, so "who pointed this Bot at that host, and when" is the first question in an incident and could not be answered. Eight event types and eight rows now, recording what changed and never a value.
The people list and the channel list grew without bound. Both were read in full on every render, and reading one person ran the whole people aggregate over the deployment twice per role change. Both are paged now, and the people screen searches on the server so somebody can be found without walking pages.
A computer accumulated one browser per Bot, forever.
COMPUTER_MAX_BROWSERSandCOMPUTER_BROWSER_IDLE_MSset the two limits. Nothing closed an idle one, so a deployment where every employee has a Bot trends toward a resident Chromium per employee in one container until it is killed for memory. There is a cap and an idle timeout, and closing one costs only a relaunch because the profile is on disk.The audit screen's filters were sequential scans. It filters by event type, by who did it and by what it was done to, and the only index was on the timestamp, over what becomes the largest table in the deployment. Each filter leads its own index now.
A deployment with no identity provider came up open by default. Covered under Changed above, and listed here too because it is the one on this list that was reachable from the internet.
Registering a company's identity provider was owned by whoever registered it. Better Auth answers its own listing route with only the providers the person asking registered, and refuses a removal from anybody else, so a second administrator opened the Identity providers screen, found it empty, and registered one that already existed. Worse, the row cascaded from that person's user row: deleting the administrator who set sign-in up deleted the company's sign-in with them. What is registered is a fact about the deployment, so reads and removals go through OpenBot's own administrator-only routes against the whole table, and a provider outlives the person who added it.
A customer's client secret was in the clear. The SSO plugin writes
oidc_configandsaml_configas plaintext JSON, with the OAuth client secret for that company's directory inside them: the one secret here not going throughKEY_ENCRYPTION_KEY. Both are now encrypted at rest. Rows written before this still read, and are re-encrypted the next time they are written. OAuth access and refresh tokens use Better Auth's own encryption, keyed onBETTER_AUTH_SECRET.A failed provider registration looked like a button that did not work. The error was rendered on the page behind the dialog, which was covering it.
Deleting a component in the playground could release one the build ships.
DELETE /api/sandboxed/:namedeleted from the shared components table by name, without checking which kind of component the name belonged to. Naming a compiled component removed its governance row, and the foreign keys took that component's per-Bot withholdings and its function grants with it. Withholding is the half that fails open: a published component is available to every Bot unless a row says otherwise, so the next catalogue announcement brought the component back published, and available to a Bot it had deliberately been kept from. The audit row called itkind: "sandboxed". The endpoint now refuses a name this surface does not own and answers 404, the way publishing already did. A governance row whose source is already gone is still this surface's to clear.A write could follow a symlink out of the Bot's workspace. The confinement resolved the directory a write would land in but not the name it would land on, so a link left at
notes.txtpointing outside was followed by the write; a read through the identical link was already refused. The gateway had already decided and written the audit row against the path as it was asked for, so a rule written forcredentials/never saw the file that was written and the trail named a file nothing had touched. A dangling link escaped the same way, because resolving the path throws where the write would still land. Links pointing back inside the workspace continue to work.A Bot could become root inside its container.
sudowas granted asNOPASSWD: ALL, and the comment above it named the two conditions that made that acceptable: the container being one Bot's alone, and not holding a database. The image meets neither, because the supervisor is deliberately not in it andEMBEDDED_POSTGRES=onis a documented way to run it. So root read another Bot's workspace, the API's environment, and the audit database recording what it did. The grant now names the package managers, soapt-get installstill works andsudo cat /proc/1/environdoes not. It is a floor rather than a boundary: code a model wrote needs a computer per Bot withCOMPUTER_SUPERVISOR_URLand a sandbox under it withCOMPUTER_RUNTIME=runsc, both of which this already supports and neither of which the single-container image can reach.A command could take the computer down, or outlive being stopped. Output was accumulated in full and only trimmed at the end, so
catof a large file allocated until the process that owns the browser died; it is now bounded as it arrives, and still reports that it was truncated rather than quietly ending. A stop signalled bash alone, sosleep 30 | catleft its children holding the pipes and the call never returned; the whole process group is signalled now. AtimeoutMsof zero or less killed the command before it started and called it a timeout; it has a floor as well as a ceiling.Stop did not reach a running command. The
/execroute never took the person's abort, so the plumbing for it was dead code and a stopped run left the command finishing inside the container.The live-screen socket did not check the address it was given. Every acting path resolved through the gateway, which refuses a foreign or cloud-metadata address; this one asked the provider directly and then put
COMPUTER_TOKENin the query string of whatever it was told.COMPUTER_SHELL_ENVrefuses the names that run before a command. NamingGITHUB_TOKENis an operator deciding a Bot may use a token. NamingBASH_ENV,ENV,LD_PRELOADor the shell option variables is handing a Bot a hook into every later command, which is unlikely to be what was meant, so those are refused and said out loud rather than passed. A name that is not a variable name is now reported too, instead of quietly disappearing.A deny rule naming one field refused every action that did not have it.
deny: contains(command, "rm -rf"), the example the documentation gives, refused every click, keypress, navigation and file read in the deployment. Two correct behaviours combined into a wrong one: the policy context left out fields an action did not have, cel-js treats a missing field as an unknown identifier and throws, and a thrown deny counts as a match so that a mistyped deny refuses rather than quietly permitting. Every field is now bound, with a neutral value where the action has nothing to put there, so a rule about a shell answers honestly about a click instead of refusing it. Rules about the action they are for are unchanged. The audit row still omits what did not happen.A command longer than 45 seconds reported failure while it carried on running. The transport gave every call the same deadline, which was shorter than the shell's own 120 second default and 600 second maximum, so
apt-get installtold the person the computer had not responded and then finished installing inside the container. A command now gets a deadline that outlasts the shell, which reports a timeout itself and says so.A Bot's shell no longer inherits the deployment's environment. Commands ran with the computer process's own environment, so
envin the one-container image printedKEY_ENCRYPTION_KEYand the rest of.env. The shell now receives PATH, locale and terminal names, and the proxy variables. Userinfo is stripped from a proxy URL, so a password inHTTP_PROXYis not inenv. Anything else is named inCOMPUTER_SHELL_ENV.A deployment served over plain HTTP could not start a conversation. The chat surface minted identifiers with
crypto.randomUUID, which browsers withhold outside a secure context. On a laptophttp://localhostcounts as one, so this never showed up in development; on a real address it does not, and the surface did nothing at all when you pressed send. No message, no error. Ids now come from an API with no such restriction.A Bot asked to be signed in, in words, and nothing happened. Handing over the browser is a tool call, and a sentence in the transcript is not one: "please sign in and let me know" leaves the person with no wheel to take and the page where it was. Bots wrote that sentence anyway, and one went further and asked for a username and password to be typed into a sign-in page nobody could reach. The guidance now says that calling
computer_request_helpis what asking means, names the sentences that are not it, and says the person cannot see the page at all until control is handed over. Asked to file an issue on a site it was not signed in to, a Bot now offers the wheel on the first attempt instead of the third.A package Bot did not know it had a computer. The instructions that make the computer usable — snapshot before acting, and ask a person to take the wheel at a sign-in rather than reporting the task as impossible — were imported by the two shipped Bots and by nothing else, so a built-in agent knew only the role its package gave it. The tools were on offer to it the whole time. Asked to file an issue on a site it was not signed in to, it browsed to the page, said it could not, and never called
computer_request_help, so nobody was ever offered the wheel. Built-in agents are now told the same thing the shipped Bots are told, wherever a computer is configured.A chat could quietly forget everything and carry on. The browser remembers a thread id for each Bot, and nothing ever asked whether Intelligence still had that thread. Where it did not, the transcript loaded empty, every later message silently recreated an empty thread under the same id, and the Bot answered as though the conversation were new — with the reason nowhere but the server log, as a 404 flattened into a 500 by the time it reached the browser. A remembered thread is now checked before it is used: one the platform provably does not have is replaced, because there is no conversation left to lose, and a check that fails for any other reason keeps the thread and says on screen that earlier messages could not be loaded. A person reading a confident answer can now tell whether the Bot has read what came before it.
The first browser action a Bot was ever asked for failed. Creating a computer and starting it are two calls to Docker, and a name the daemon has not published yet answers the second with a 404. The supervisor treats that as a lost race and rebuilds, which is right, but it went straight back round: the retry landed a millisecond later, saw the same unpublished name, and spent the only other attempt on it. The whole request then failed as Docker being unreachable, the person was told the computer could not be started, and the next message worked. It waits one poll interval before rebuilding now, which is what the health wait already uses for the same question.
A framework Bot asked for a browser action and nothing happened.
agent-langgraphends a run when the model calls a tool the surface owns, which is how a tool that lives in the browser is supposed to work: the run finishes, the surface acts, and the next run carries the result. But the call was only reported to the surface from the node that executes this deployment's own tools, and that node is exactly what an ending run skips. The person saw their own message, no answer under it, and no explanation, because a run that finishes carrying nothing is not an error. Every Bot action in the browser was affected: opening a page, filling a form, asking for help at a sign-in.
Changed
- A retention policy for the audit trail.
AUDIT_RETENTION_DAYSremoves rows older than the window it names, swept hourly by whichever server holds an advisory lock. Unset by default, because deleting somebody's audit trail because a default said so is the worse of the two failures. The trail stays append-only: the database permits a delete only when the transaction declares a retention window and only for rows already outside it, so removing recent rows is still impossible and anUPDATEstill is under every condition. allowed_groupsis documented as a declaration, not a control. The tenant package writes it and nothing reads it on any access path, andusers.groupsis written by nothing either, so both halves of the rule are waiting on group membership arriving from the identity provider. Channel access is membership alone. The columns stay, because they are the right shape for the rule they are named for. Thanks to @NathanTarbert and @andreolf.- Running with no sign-in takes a flag and nothing else. It used to be locked with
NODE_ENV=production, which is exactly backwards:NODE_ENVis unset unless somebody sets it, so a container on a VM with a hand-written env file and no identity provider served every visitor on the internet as an administrator, silently, because nothing looked wrong from the outside. A deployment with no provider now refuses to start unlessOPENBOT_SINGLE_USER=truesays it was meant..env.exampleships that line switched on, so a clone still runs with no configuration at all, and the line is greppable in a way a default never was.OPENBOT_DEV_NO_AUTHis still honoured. - Requires Better Auth 1.7, which adds an
issuerto every account. Migrations0002and0003add the column and backfill existing rows with their provider's real issuer, so nobody is asked to sign in again. The column stays nullable on purpose: a rolling deploy runs migrations and then serves from old and new replicas at once, and an old replica writes an account without it, so making it required in the same release would break the first sign-in of everybody who landed on a replica that had not been replaced yet. The constraint belongs to a later release. - Where a Bot's computer runs is now a plug. One
ComputerProviderinterface sits under the gateway, with the Docker supervisor as one implementation and a shared computer as another. A computer somewhere else is an adapter rather than a change to the governed path. Thanks to @mu-hashmi for the refactor. - The address a provider hands back is checked before anything is sent to it, and the cloud metadata addresses are refused whatever a provider says.
- The container image runs as an unprivileged user rather than root.
0.0.1
First tag.