Model or dataset
risa-labs-inc/BossConsole avatar
risa-labs-inc/BossConsole

BossConsole exposes its own tabs, terminal and git as 100 plus MCP tools

Open-source, multi-platform harness for AI agents - a native, multi-threaded operator's console (JVM, not Electron) to run Claude Code, Codex, Gemini or OpenCode with a real browser, terminal, editor, secrets & 100+ MCP tools. Built for enterprises, science & research.

817 stars161 forksKotlinApache-2.0

At a glance

What is it?
BossConsole is an Apache licensed desktop harness for AI agents, written in Kotlin Multiplatform and running on the JVM rather than Electron. Its central design decision is that the agent's tool layer is the application: the same MCP surface an agent uses to do work also exposes the app's tabs, terminals, browser, editor, git and secrets back to it.
Who is it for?
BossConsole is a serious piece of work with an unusual bet: the application is the agent's instrument, not the thing the agent watches. That bet pays off for anyone running long autonomous tasks in a workspace they control, and it is the reason the browser benchmark, the reproducible harness and the committed per-run data matter more here than usual.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Kotlin, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • risa-labs-inc/BossConsole817 ★ · +210
Star history
Repository2026-09-112026-11-15
risa-labs-inc/BossConsole607817

210 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The application is the agent's tool surface

The architectural claim is stated in one line: the app is both the agent's home and an app the agent can operate. The mechanism is that the MCP layer the agent uses to do work also exposes the application itself, as more than 100 tools named with an `mcp__boss__` prefix, covering tabs, terminals, the browser, the editor, git, secrets and automation.

Those tools split into two kinds, and the split is the design. Read-only tools give situational awareness of the running workspace: listing tabs, reading the output of a pane, tailing the console, snapshotting performance, inspecting git state. Action tools then let the agent act on what it found. So the agent is not describing your code back to you, it is looking at the same live application you are and driving it through multi-step tasks.

That has a clear upside and a clear cost, and the page is honest about the direction of both. The upside is that an agent doing a long task has real instruments rather than a chat transcript. The cost is that every instrument is a way to change your machine, including the terminal and the editor, which is why the page spends a section on deciding what each agent may touch rather than presenting the tool count as a feature on its own.

Secrets go to the browser and never reach the model

One design decision is specific enough to be worth separating from the marketing. The embedded browser, called Fluck, can be navigated, scripted and automated by the agent through named operations including navigation and running JavaScript, plus record and replay automation. The logins that browser needs are filled from a built-in Secret Manager, and the page states they are never handed to the model.

That is a narrower and more believable claim than most, because it is scoped. The agent gets a session that is already logged in and does not get the credential, which removes the usual failure mode where a browser automation agent has to read a password out of a form. The cost is that the Secret Manager becomes part of the trusted computing base, and the page does not describe how entries are stored.

The other half of the governance story is per tool. The comparison table credits BOSS with per-tool governance described as role based access control plus a kill switch, while noting that the enterprise plans of the alternatives do have admin controls but that fine-grained per-tool role based access is not documented for them. The shareable terminal carries the same treatment, with end-to-end encryption named in the row about handing a live terminal to another device by QR code.

The browser benchmark publishes its own caveats

The performance section is the most useful page in the repository because it argues against itself where it should. A Speedometer 3.1 run is reported for the embedded Fluck browser and five desktop browsers on the same M3 Max Mac, with each median taken from three runs of ten iterations. The results: Fluck 47.9, Comet 46.2, Chrome 35.5, ChatGPT Atlas 34.6, Safari 29.9 and Firefox 22.5.

Then the caveats, stated before the conclusion rather than in a footnote. Fluck and Comet should be treated as tied within measurement precision. A follow-up experiment alternated the two back to back three times, and Fluck led every pair, but its 3.4 percent median margin sat inside the browsers' own run to run spread and was not significant at p = 0.125. Absolute scores were depressed by heavy co-tenancy, 800 to 1300 percent ambient CPU including roughly four cores from a running container desktop, so browsers should be compared within the experiment rather than against published figures from quiet machines. Safari ran on a live profile with existing tabs and extensions and is therefore not comparable to the fresh-profile runs, and Firefox varied by 40 percent across its three runs, making its median the least stable number in the table.

The durable claim is stated as a comparison, not a magnitude: Fluck and Comet both scored roughly 30 percent above Chrome and Atlas in these conditions. A report, a reproducible harness, per-run JSON and screenshot evidence are committed to the repository.

The absolute scores cannot be read as browser speed

It is worth pulling one number apart, because a median of 47.9 on a machine that also ran four container cores says less about the browser than a reader will assume. On a quiet machine a Speedometer 3.1 score is normally far higher, and the page says so by instructing the reader not to compare these figures with published ones. The ranking is the claim; the magnitude is not.

That distinction decides how much weight the benchmark can carry. Within a single machine, a single session, one configuration, three repetitions and a named workload, the ordering is a fair basis for saying the embedded browser is competitive with the best of the field and ahead of two mainstream browsers. It is not a basis for saying it is fast in absolute terms, or for predicting how it behaves on a workstation doing other work.

The comparison set deserves the same scrutiny. Two of the five are newer AI-facing browsers, one of which, Comet, came within measurement precision of the winner, so the result is closer to a lead over two mainstream engines than a lead over the field. The Safari and Firefox entries are self-flagged as the weakest numbers in the table, which is to their credit and to nobody else's.

Installers live in a second repository

The download path is split from the source path, and the split is stated plainly near the top of the page: a reader who only wants BOSS is sent to a separate repository for pre-built installers. The two badges at the top of the README point at that releases page, and the code repository's own releases carry titles that simply repeat the version, the most recent being 9.5.34 on 2026-10-01 after 9.5.33 and 9.5.32 on the two preceding days.

Three releases in three days on a patch number in the thirties is a project shipping very often, and it is worth noting what that cadence implies for anyone evaluating it. A console that can rewrite its own tools at runtime is already a moving target; releasing daily means the version a review looked at may not be the version a team deploys next week. The version lives in its own properties file at the repository root rather than in the Gradle build, which is how a repository like this keeps the tag, the build and the window title in agreement.

For anyone tracking releases, the practical consequence is that watching the code repository's tags tells you a release happened, and following the installer repository tells you what to run.

The README is machine written, including the competitor table

The root contains a document whose name explains a lot: an instruction file for automatically updating the README. Alongside it sit a blame ignore list for bulk reformatting commits, an editor config, agent instruction files, and a contributor guide. The implication is that at least part of this page is generated by the build rather than typed by a person, and the comparison table is the part that shows it.

That table is the most assertive content in the repository. It sets BOSS against five named products across eleven rows, marks each cell yes, partial or no, and then carries six footnotes making claims about those competitors: that only the Codex command line tool is open source while the desktop app is proprietary, that a competing browser mode controls the whole screen instead of bundling a scriptable browser, that competitor enterprise plans have admin controls without documented fine-grained per-tool access, that extensions in fork-based editors reload through a full window reload, and that Electron applications run on a single-threaded event loop with worker and child process offloading.

Each of those is checkable by the reader and the page invites corrections through issues or pull requests. The detail that matters for interpretation is the date: the table says it was compiled from public sources in July 2026, and the last push to the default branch is dated 2026-10-02. Three months is not very long, but the products in the table are exactly the ones that ship weekly.

A JVM console with a browser, a terminal, an editor and a tool evolver

The component list explains the scale of the thing. Kotlin Multiplatform and Compose Multiplatform for the shell, running on the JVM with real multithreading, which the page sets against Electron's single-threaded event loop. An embedded Chromium with its own branding directory at the root. A shareable terminal, called BossTerm, that can be handed to a phone by QR code. A code editor. A plugin store, called the Toolbox, with more than a hundred plugins available. And a browser automation path with record and replay, accompanied by a small HTML page at the root that looks like a fixture for testing it.

The feature with the longest shadow is runtime evolution. Plugins hot-reload while the application keeps running, and the page describes a tool evolver that lets an agent change a tool and see the result immediately without a restart. Every other feature here is a capability a user opts into. This one means the tool surface is not fixed at build time, which is the single thing to weigh carefully before handing an agent access to it: the blast radius described in the first section grows during the session.

The rest of the root is build and release machinery, which for a project shipping installers daily is a large part of the work: two Windows build scripts, one for an MSI and one for a standalone build, a Windows build guide, a code signing setup guide, a local certificate check script in PowerShell, a macOS icon file and a separate readme for the JAR artefact.

A desktop console with a server directory and a Supabase directory

The repository is organised as a Kotlin Multiplatform project with the usual structure and a few entries that do not fit that description. Alongside the application directories, the build tooling and the documentation, the root holds a `server/` directory, a `supabase/` directory, an `infra/` directory, a `config/` directory, a `plugin-platform/` directory, a `shared/` directory, a `modules/` directory, a `composeApp/` directory, a `scripts/` directory and a `buildSrc/` directory.

For a project whose central promise is that you run the console on your own machine, a server directory and a Supabase directory are the two things a careful evaluator will want explained, and the page explains neither. They may be a self-hosted backend for accounts and entitlements, a hosted control plane, or build-time tooling; the repository does not say which, and nothing in the README describes an account requirement, a sign-in step or a network dependency.

That is an omission rather than a red flag, and it is the kind of omission worth resolving before deployment rather than after. The governance features and the secret manager both imply some notion of identity, and identity is where a hosted component would live. Everything else about the layout is predictable: a Gradle build with a settings file and properties, a wrapper committed, a version file, and a build script directory for shared build logic.

Editorial conclusion

BossConsole is a serious piece of work with an unusual bet: the application is the agent's instrument, not the thing the agent watches. That bet pays off for anyone running long autonomous tasks in a workspace they control, and it is the reason the browser benchmark, the reproducible harness and the committed per-run data matter more here than usual. Three things to check before adopting it. Establish what the MCP surface can reach, because 100 plus tools covering git, secrets and terminals is a large blast radius even with per-tool role based access and a kill switch. Read the benchmark report rather than the table, since the page itself says the absolute scores cannot be compared with published numbers. And check what the server and Supabase directories at the repository root are for, because the page promises a console you run on your own machine and does not describe those two directories at all.

Frequently asked questions

What is BossConsole?

It is an Apache-2.0 desktop harness for AI agents, built with Kotlin Multiplatform and Compose Multiplatform on the JVM. It runs Claude Code, Codex, Gemini or OpenCode inside a native application that bundles an embedded browser, a shareable terminal, a code editor, a plugin toolbox and a governed MCP tool layer.

What can a BossConsole agent do to the application itself?

Its MCP layer exposes the application as more than 100 tools covering tabs, terminals, the browser, the editor, git, secrets and automation. Read-only tools such as listing tabs, reading a pane's output, tailing the console, snapshotting performance and inspecting git give situational awareness, while action tools let the agent act on what it finds.

Does BossConsole hand my passwords to the model?

The page states that logins used by the embedded browser are filled from a built-in Secret Manager and are never handed to the model. Access is governed per tool with role based access control and a kill switch, and the shareable terminal is described with end-to-end encryption.

How does the BOSS browser compare to Chrome?

A Speedometer 3.1 run on one M3 Max Mac reports 47.9 for the embedded Fluck browser against 35.5 for Chrome and 34.6 for ChatGPT Atlas, each median from three ten-iteration runs. The page states Fluck and Comet are tied within measurement precision at p = 0.125 and that absolute scores were depressed by 800 to 1300 percent ambient CPU.

Where do I download BossConsole?

Pre-built installers are published in a separate repository, risa-labs-inc/BossConsole-Releases. The code repository carries its own releases, currently 9.5.34, with titles that repeat the version and roughly one release per day.

Is BossConsole built on Electron?

No. It is built with Kotlin Multiplatform and Compose Multiplatform and runs natively on the JVM with true multithreading. The comparison table in the README marks Claude Desktop and the VS Code fork editors as Electron based, which it describes as a single-threaded JavaScript event loop.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. risa-labs-inc/BossConsole on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/risa-labs-inc-bossconsole.svg)](https://hysenlabs.com/projects/risa-labs-inc-bossconsole)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/risa-labs-inc-bossconsole.svg)](https://hysenlabs.com/projects/risa-labs-inc-bossconsole)

Was this useful?