Skales: a closed-source desktop agent that ships as a signed installer, not a repo you build

What Skales actually is, and who it is built for

Skales is a personal AI agent that runs on your own machine rather than in a cloud account. The README describes it as "The private AI that lives on your computer and does real work, not just chat." It reaches your files, browser, calendar and email, and it runs multi-step work on its own through a `/goal` command that the README says continues in the background and picks up where it left off.

The audience is explicit and unusual for this category: the README says it is "made for everyone from 6 to 60+", and the install story is a downloaded EXE, DMG or AppImage. There is no Docker requirement, no terminal step, and no Python environment to assemble. For an engineer, that framing matters less than the consequence: the thing you evaluate is a signed application, not a dependency graph.

The repository is the distribution channel. Releases, the changelog, install guides and the issue tracker live there. The README states plainly that Skales itself is closed source under BSL 1.1, and that the source tree checked in is a historical v7 snapshot which is "not maintained, not built and not what runs on your machine." Treat the repository as a release feed with documentation attached.

How the agent runs: Electron shell, provider layer, local tools

The checked-in snapshot is an Electron application. package.json sets `"main": "electron/main.js"` and depends on `electron-updater` and `electron-store`, with `electron` and `electron-builder` in devDependencies. The build scripts chain a bot bundling step, a web build inside `apps/web`, a dependency packing step, then `electron-builder` per platform. That is the shape of the v7 code, and the README is clear it is not the shipping product, so read it as an architectural hint rather than a specification.

The product-level mechanism is a provider layer plus local tools. The README says you can start with Skales IQ, a free built-in trial that needs no API key, then bring your own key from 15+ AI providers, or run fully offline with Ollama. Model choice is therefore a configuration decision, not a code change. Tool access is what makes it an agent rather than a chat window: files, browser, calendar and email, with `/code` binding a folder to a chat and offering inline diffs and one-click undo.

Multi-device behaviour is part of the architecture. The README describes pairing a phone by QR so the phone drives the desktop's full tool set, or running the phone standalone. It also lists Teams for pairing two desktops, Agent2Agent, Workflows and multi-agent organisations. Those are documented features, not things this article has exercised.

Installing Skales and running a first goal

Installation is a download, not a build. The README links platform-specific installers from skales.app: `latest-windows`, `latest-mac-arm64`, `latest-mac-intel` and `latest-linux`, plus Android through Google Play and iOS through the App Store. The repository also carries INSTALL-WINDOWS.md, INSTALL-MAC.md and INSTALL-LINUX.md at the top level for platform notes.

The README gives no package-manager command and no shell installer, so there is nothing to put in a terminal block here. What it does document is the first interaction: a slash command that hands the agent a goal.

/goal build me a trading bot

According to the README, that runs in the background across many steps and resumes where it left off, which is the behaviour the phrase "hand it a goal and close the lid" is describing. The second documented entry point binds a working directory to the conversation so the agent can edit files with diffs you can review and undo.

/code

If you are moving from another tool, the README points to Settings > Import from Another Tool and names OpenClaw, Hermes Agent and ChatGPT as supported sources. That importer is the migration path; the README does not describe what it transfers.

The source tree you can read is not the product you run

This is the limitation that should drive the decision. The README states that the checked-in source is a frozen v7 snapshot, while the current release line is v12.9.26. package.json confirms the mismatch: its `version` field reads `7.1.0`. Anyone who clones the repository expecting to build the agent they saw in the demo will be building a historical artifact.

The practical consequences are concrete. You cannot audit the code that runs on your machine. You cannot patch a bug yourself and ship it. You cannot verify a security claim by reading the implementation. The README anticipates this and routes security reports to SECURITY.md, which it says defines what is in scope, but a scope document is not the same as readable source.

There is a second, quieter cost: issue triage. Because the repository is the issue tracker for a closed product, a bug report cannot be accompanied by a patch or a line reference. If your team's workflow assumes "file it, fix it, open a PR", Skales does not fit that workflow at all.

Licence terms and what BSL 1.1 means for a team

The README says Skales is "closed source under BSL 1.1 · free for personal use". The repository carries both LICENSE and COMMERCIAL-LICENSE.md, and the GitHub metadata reports the licence as NOASSERTION, which means the platform could not classify the file automatically. Read both files rather than trusting a badge.

BSL licences generally grant source-available rights with restrictions on production or commercial use until a change date, but the specific terms here live in LICENSE and COMMERCIAL-LICENSE.md, and this article cannot tell you what they say. The honest position is that the personal-use grant is stated in the README and the commercial path is a separate document. If you are deploying inside a company, that document is the one to read, and if the answer is not obvious from it, that is a question for your legal team rather than for a review.

One more thing worth noting for anyone planning to build on the repository: THIRD-PARTY-NOTICES.md exists at the top level, which suggests the shipped application bundles third-party components. The README does not enumerate them.

How Skales differs from a self-hosted, code-first agent stack

The obvious alternative for an engineer is a code-first, self-hosted agent framework where you own the source, wire up your own model endpoints and run it behind your own process manager. The difference is not features, it is who carries the operational burden and who can read the code.

With a code-first stack, you get auditability, patchability and a deployment you can put in CI. You also get the setup work: runtimes, container images, model configuration, and a debugging loop that starts in a terminal. Skales inverts every one of those. Setup is a double-click, the README claims roughly 300MB of RAM against 1.5GB to 3GB+ for typical agents in its comparison table, and the target user is explicitly not a developer. In exchange, you give up source access and you accept a vendor's release cadence.

A narrower alternative for the same job is running a local model through Ollama behind an editor or chat client you already trust. That keeps everything offline and keeps the code open, but it does not give you the desktop tool surface: file binding with undo, browser and calendar access, phone pairing, or background goals that survive closing the lid. The choice is between an open stack you assemble and a closed application that arrives assembled.

Release cadence, upgrade cost and what to verify before adopting

The last push to the repository was on 2026-09-07, and the release list shows v12.9.26 on 2026-09-06, v12.9.25 on 2026-09-03 and v12.9.21 on 2026-09-02. That is a fast cadence with named builds (Grip, Backbone, Cockpit 2.0), and it is the kind of rhythm that implies frequent update prompts. Because the desktop app depends on `electron-updater`, upgrades are handled inside the application rather than by a package manager.

The upgrade cost is therefore low in effort and high in unpredictability. You do not schedule upgrades; they arrive. For a personal machine that is fine. For a fleet, it means you are trusting a vendor's release process with no ability to pin a commit, because the commit you can see is a v7 snapshot unrelated to the running build.

What to verify first: read SECURITY.md to understand what the maintainers consider in scope before you report anything, read LICENSE and COMMERCIAL-LICENSE.md for your specific use, and confirm whether the migration importer in Settings > Import from Another Tool covers the tool you are leaving. The README names OpenClaw, Hermes Agent and ChatGPT as sources; it does not describe the fidelity of the import.

Editorial conclusion

Adopt Skales if you want an autonomous agent on a personal machine and you are fine with a closed-source binary, a BSL 1.1 licence and no Docker or terminal in the loop. Do not adopt it if your procurement requires auditable source, or if you plan to fork and self-build, because the tree in the repository is a frozen v7 snapshot that the README says is not built and not what runs. Before installing, verify what SECURITY.md puts in scope, confirm the licence terms in LICENSE and COMMERCIAL-LICENSE.md for your use case, and check whether the migration importer covers the tool you are leaving.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. skalesapp/skales on GitHub