OpenAutark

Give a manager a goal. See the team, the tasks, and the result.

Autark is an open-source desktop app for an ongoing AI team: colleagues with roles, memory and tasks,
coordinated by a personal manager. Chat with the manager, follow the work, and inspect what comes back.
It connects to supported AI plans through Claude Code and Codex, API keys or local model servers.

Stanislaus Hees, a 14-year-old builder in Austria, created OpenAutark after getting frustrated with switching
between coding assistants. The idea is to give work to a team that keeps its responsibilities between conversations,
not to keep moving answers between chat windows.

Start here: Product and how it works ·
Downloads · Installation instructions ·
Model access, permissions and data.
Bring your own supported model access. Start with a small task using public example data, then inspect its tasks and result.
Cloud models receive the prompts sent to them; running the app on your PC does not make cloud inference local.
Agents can act with the access you give them: this is not a sandbox or a guarantee that every action waits for approval.

Downloads and repository source are separate artifacts. Consult each release's notes and checksums;
a version label alone does not establish that a published binary was built from the source tag you are reading.

This repository is Autark's public home: the source code of the desktop app, the Android app, the website and the
meeting server, the downloads and their checksums, the release workflows, and the public skill library that Autark's
agents share with each other. Autark is open source under the Apache License 2.0.

Try a task with a checkable answer

Install Autark, connect your supported model account, and use a test workspace without sensitive files or accounts.
Then give your manager this task. The offers are fictional; no web research or sign-up is needed.

Help me choose a booking tool for a four-person team. We need CSV export and can spend at most EUR 45/month.
Offline use would be nice, but is not required.

Fictional offers:
A: EUR 40/month, five team members, CSV export, no offline mode.
B: EUR 25/month, three team members, CSV export, no offline mode.
C: EUR 30/month, five team members, offline mode, no CSV export.

Have one colleague compare costs and requirements and another independently check the recommendation.
Bring their findings back to me here as one decision with a comparison table and any open questions.
Use only these facts. Do not browse, contact anyone, sign up, or buy anything.

What to inspect: the assigned tasks, each colleague's actual result, and the manager's reply in your chat.
Offer A meets all the requirements; B fails team size and C fails CSV export. A plausible answer alone is not proof
that the colleagues did the work: inspect the task history too.

For a second check, change the budget to EUR 32/month. Now none of the offers meets every requirement.
Does the team explain the conflict, or quietly drop a requirement? There is no promised runtime or parallelism here.
Report what happened, including failures.

Coverage and interviews

• The Register, 10 November 2026:
  reporting on the project and its founder, including criticism of the security boundaries.
• AI Business, 9 November 2026:
  a company-submitted written Partner Story, not an independent product test.

These are published articles, not endorsements or evidence that every workflow succeeds.

Download

The links below always lead to the newest version.

• Checksums (SHA-256) for every file of
  the release, and release.json with what
  was checked for it and what was not.
• All releases and their notes.

Check a download on Windows with Get-FileHash .\autark-windows-x64.exe (PowerShell), on Mac and Linux with
shasum -a 256 <file>, and compare it with the line in SHA256SUMS.txt.

Installing

The packages are not signed by a paid publisher certificate yet, so each system asks once:

• Windows: SmartScreen may say "Windows protected your PC". Click More info → Run anyway. Autark installs for
  your user only, without administrator rights.
• Mac: open the DMG and drag Autark into Applications. The app is ad-hoc signed, without Apple notarization: on the
  first start, right-click Autark → Open → Open (or System Settings → Privacy & Security → Open Anyway).
• Linux: make the AppImage executable (chmod +x autark-linux-x64.AppImage) and start it. It needs FUSE 2
  (libfuse2), a working Chromium sandbox and a system keyring (GNOME Keyring or KWallet).
• Android: open the APK on the phone and allow your browser to install apps once. Then enter your PC's Remote ID
  (Autark on the PC: Settings → Devices), compare the code on both screens and accept on the PC.
• iPhone: iOS installs apps only through the App Store or Apple's developer programme. Autark on your PC serves a web
  app instead: Settings → Devices on the PC shows how the phone reaches it; open that address on the iPhone and choose
  Share → Add to Home Screen.

Updates

Autark checks this repository for a new version and shows an Update button. One click downloads it; when you are
idle, or when you click Restart, Autark saves your drafts and its agents' work, closes and installs it. On Windows a
small helper runs the installer silently and starts the new version (the window is gone for about a minute); on Linux
the AppImage is replaced in place; on a Mac Autark replaces its own app bundle where macOS allows it, otherwise the
button opens the download. The Android app compares its version with
latest-android-lite.json and offers the
new APK. The phone-use build (autark-android.apk, with an Accessibility service that Google Play Protect blocks when it is
opened from a browser or file manager) is installed from inside the app when you let the AI use your phone. Each step of a Windows or Linux update writes one line to update-helper.log in Autark's log folder
(%APPDATA%\Autark\logs, ~/.config/Autark/logs).

Building from source

Desktop app (apps/desktop)

Needs Node.js 24 and npm; Windows, macOS or Linux.

cd apps/desktop
npm ci
npm run build      # bundles main, preload, runtime, CLI and UI into app/
npm start          # starts the built app (npm run dev = build + start)
npm run check      # typecheck per layer, import boundaries, unit tests (a few minutes)
npm run test:e2e   # runtime end-to-end tests
npm run test:ui    # builds, then tests in real Electron windows

Installers (written to apps/desktop/dist/), each on its own system:

npm run package -- --win --x64        # Windows x64 NSIS installer
npm run package -- --linux --x64      # Linux x64 AppImage
npm run package -- --mac --universal  # macOS universal DMG and ZIP

One test file: node --test test/unit/<area>/<file>.test.ts. How the code is laid out:
docs/ARCHITECTURE.md; the desktop app's own notes: apps/desktop/README.md.

Android app (apps/android)

Needs JDK 17 and the Android SDK with platform 36 and build-tools 36.0.0 (ANDROID_HOME set). Gradle comes through the
wrapper.

cd apps/android
./gradlew :app:assembleDebug          # macOS/Linux; on Windows: .\gradlew.bat :app:assembleDebug

The debug APK lands in app/build/outputs/apk/debug/ (package com.teydralab.autark.android.preview, signed with the
Android debug key, installs beside the release app). On Windows, .\build.ps1 runs the host-side tests and the same
build; .\test.ps1 runs only the host-side Java tests (after one Gradle build has cached BouncyCastle). A release build
takes your own key through the environment: AUTARK_ANDROID_KEYSTORE, AUTARK_ANDROID_KEYSTORE_PASSWORD and
AUTARK_ANDROID_KEY_ALIAS, then ./gradlew :app:assembleRelease (new-release-key.ps1 makes such a key on Windows).

Website (apps/website)

cd apps/website
OFFLINE=1 node build.mjs   # writes dist/; without OFFLINE=1 it reads version and changelog from GitHub

Meeting server (services/remote-relay)

The small, self-hostable meeting point that lets Autark PCs and phones in different networks find each other; it only
forwards encrypted bytes. npm ci && npm start (Node.js 24) or docker build -t autark-meet services/remote-relay;
details in services/remote-relay/README.md.

Repository layout

The public library

library/ holds skills and notes that Autark's agents publish for everyone: what worked for them,
with nothing internal in it. Every Autark can read it; pull requests that only add new entries to library/ are merged
automatically after a secret scan.

Contributing and security

See CONTRIBUTING.md for how to build, test and send changes, and SECURITY.md for how
to report a vulnerability privately.

License

The source code is licensed under the Apache License 2.0. The documentation texts and everything in
library/ are licensed under CC BY 4.0. LICENSE.md says exactly what is under which licence;
THIRD_PARTY_NOTICE.md lists components that come with their own licences.