Skynet is a Mac app for working with AI agents. An agent is a folder: its prompt, its settings, its memory and whatever it makes all live in that folder, as plain files you can read and edit. The app runs the agent through one of three engines — claude, codex or pi — and shows the conversation.

Open this guide with ⌘?, from Help → Skynet Guide, or with the ? at the bottom of the sidebar. The field at the top finds a word or phrase as you type: every place it occurs is marked, the page jumps to the first, ⏎, ↓ or ⌘G goes to the next, ⇧⏎, ↑ or ⇧⌘G back, and Esc clears it. The same file is kept at ~/Skynet/GUIDE.md, so an agent can read it too. It is rewritten from the app on every launch, so edit the app's copy, not that one.

The window

The window has three columns — sidebar, chat list, chat — or two when a page (Dashboard, Studio, Automations, Telegram, Search) is showing: sidebar and page.

Sidebar

Every section folds: click its name. A folded section keeps the agent you have open in view, and its name carries one mark for each kind of thing the hidden agents have — the same marks as the rows, most urgent first — so nothing that needs you can hide in a fold.

The mark on the right of an agent says what it is doing. Three colours, one meaning each: green is moving, amber is something for you to do, red is something that failed.

One slot per agent. When several things are true the higher one shows: hand, check, red, retrying, pulse, ring, amber dot. Your desk first, then what is moving, then what is only to read. A dot clears only when you open that chat or run — its row in the list, a notification, a search hit — not by arriving at the agent with it on screen. Catch Up on the agent's right-click menu clears them all at once. The same marks mean the same on a chat row and under the Automations and Autopilot sections. A failed run or a check that cannot run is red on its agent's row, not anywhere else — the sidebar's Activity item carries only the app's load.

Chat list

• Search this agent — press ⏎ to search the titles and the text of every chat in this agent. A match shows the line it was found in.
• New chat — clicking it again reuses an empty chat rather than making another. If you started writing in a new chat and then opened a different one, New chat takes you back to that unsent message. A chat with unsent text carries the same faint pencil in the chat list (not the one you have open); a new chat that has no row yet shows it beside New chat.
• Chats are grouped Pinned, Today, Yesterday, This week, Earlier. Right-click a chat to Pin to top or Unpin.
• Rename… on the same right-click gives a chat whatever name you like, instead of the one its engine made up. The name is Skynet's own — the chat itself is not touched — and clearing the field — or Reset, once a chat has a name of yours — gives the engine's title back. It is the only way to name a codex chat, which is otherwise always called whatever you said first.
• Delete, last on the same right-click, moves the chat's file to the Trash — on any engine — so a wrong click is undone by dragging it back. It is off while that chat is working; stop it first. A command run's row has no file and simply goes.
• Each row shows the engine's logo, a clock if an automation made it, a paper plane if you have written into it from Telegram, and the same marks as the sidebar.
• A chat that has never run but holds queued messages sits at the top with a clock and "queued".
• Autopilot, above Pinned, for an agent with it switched on (Agent Settings → Autopilot). Only tasks waiting for you, ready to review, or being worked; a line under them counts the rest. The header opens the agent's Autopilot page. See Autopilot.

There is no rename or delete: a chat's title is the engine's own title for it, or its first message.

Chat

A new chat opens on a greeting and the agent's quickstarts — buttons that fill the message box for you to finish. They never send on their own.

In the conversation:

• Tool calls fold into one line, "N tool calls · time"; click to open them. Errors never fold.
• Cards stand in for files, links and references — click to open. An .html or .svg file opens in a window of its own inside Skynet, with its styles and images.
• Questions, permission requests and plans appear as cards to answer: Answer, Allow / Always allow / Deny, Approve / Revise. A question also has Skip: it is left unanswered, and the agent stops and waits for you. Writing a message instead of answering does the same — the question is skipped and your message goes next.
• Above the message box, outside the scrolling chat, sit the working dots while a turn runs and the task chip. The task chip shows background work — subagents, background commands, schedules — that outlived the reply. Under it, one row per task: what it is, and for a subagent the tool it last used, its step count and how long ago its last step was. A subagent whose last step keeps getting older is probably stuck. Stop on a row stops that task alone; the chat and its other tasks keep going (claude only). The chip's ■ ends the chat's whole session and everything running in it.
• latest ↓ appears when you have scrolled up while the agent is writing; it jumps back to the end.
• Drop a file, a folder or an export (Photos, Preview) anywhere on the chat to attach it. Exports are saved into the agent's .skynet/files/.
• ⌘V in the message box attaches too: files copied in Finder, and a copied image — a screenshot taken to the clipboard, "Copy Image" in a browser — which is saved into .skynet/files/ as Pasted image <date>.png. Copied text that happens to carry a picture beside it (Word, Notes, a web page) still pastes as text.

Message box

• Launching the app, switching agent, and starting or opening a chat — New chat, ⌘N, a click in the list, ⌘↑/⌘↓, a notification, a search hit — put the cursor here, ready to type.
• ↩︎ sends. ⌘↩︎ also sends. ⇧↩︎ starts a new line. While a turn is running in this agent, ↩︎ queues the message for when it finishes. One chat per agent runs at a time — unless the agent has Chats run in parallel on (Agent Settings → Engine), when only the chat that is itself running queues.
• / lists skills. @ pulls things in: files, any installed source (Notion, Bear, Slack…), a context, or another agent. Type after it to search: @notion roadmap.
• ↑ in an empty box brings back your last message in this chat; ↑ again goes further back, ↓ comes forward. Edit the text and the arrows move the caret again.
• Queued messages each have four buttons: ↑ sends into the turn running now, ↓ takes it back into the message box to edit (anything already typed there is kept, below it), ⏸ holds it until you decide, ✕ discards it.
• The box grows with what you type, up to about eight lines, then scrolls. Drag its top edge to make it taller, up to half the window, or back down to its normal height — a grip shows when the pointer is over it. That height is kept for every chat and across launches. Double-click the edge to let it grow with the text again.
• The paperclip attaches files; so does dropping them.

The chip bar under the box sets how the next turn runs. Every change is saved to the agent at once.

The round button sends; while a turn runs it becomes Stop (⌘.). Stop twice ends the session.

When the trial is over and there is no key, Skynet shows a window of its own instead of the app: Buy Skynet — €99, Enter a key… and Redeem a code…. Your agents, chats and files stay on the Mac untouched; scheduled automations wait, and a message from Telegram gets a sentence saying why. See Licence and trial.

Toolbar

Everything up here is about the agent in front of you. In from the right edge:

• Brave (or a globe for Chrome) — the shared browser, if the cobrowser skill is installed. Which one it is is set in Settings → Setup → Agent browser. Right-click to quit it.
• Plan status — the account badge and, beside it, three small columns: the 5-hour window, the week, and this model's own cap, left to right. They share one scale, so the tallest column is the one nearest its limit. Faint under 70 %, amber over 70, red over 90. Hover it for every number — each window's percentage, when it resets, and which account is paying. The badge turns amber with ↩︎ when it is borrowing another account because the chosen one is over 70 %.
• Zed (</>), Terminal, Finder and person-with-gear — the agent's folder in each, and Agent Settings. The terminal is Terminal or iTerm, as Settings → Setup → Terminal says.
• Link chips — the addresses in the agent's .skynet/links.md, or its development box. See Links.

The two controls that are about the app rather than about an agent — the gear (App Settings) and the ? (this guide) — are at the bottom of the sidebar, beside + Add agent…. ⌘, and ⌘? reach them whether or not the sidebar is showing.

The speaker beside them is the sound. Click it round: All (speaker with waves) — macOS's Ping when a chat finishes while you are not looking at it, Tink when an automation finishes; Chats only (a speech bubble with a speaker in it) — the Ping, and automations silent, their failure banners included; Off (speaker struck through) — no sound at all, notifications still appear silently. The chat you are looking at never pings.

Keyboard shortcuts

Right-click menus

Close only takes an agent out of the sidebar. The folder and everything in it stays; add it again any time.

Agents

Any folder can be an agent. Adding one writes a starter CLAUDE.md if there is no prompt yet. What the app keeps in the folder:

All of .skynet/ is plain files. Changes take effect at once — no restart.

Favourites: right-click → Add to Favourites. The first nine get ⌘1–⌘9, and the window opens on ⌘1.

Groups: right-click → Move to Group › New Group…, give it a name, and the agent is in it. The groups are kept in ~/Skynet/sidebar.json, with which sections are folded.

Rename: right-click → Rename…. An agent is a folder, so this renames the folder where it stands — and takes its chats with it. That last part is why the menu item exists: all three engines file an agent's chats under the path it had, so renaming the folder in Finder leaves every past chat behind, still on disk but no longer reachable from the agent. Renaming here moves claude's and pi's chat folders and rewrites the folder recorded inside each codex thread. An agent that is working will not rename — let the turn finish first — and any session it has open is closed, which costs nothing: the chats reopen from disk.

Another agent's folder can be pulled into a message with @agent: it inserts the folder's path, and the agent reads its prompt, settings and files from there.

Prompts, contexts and memory

Every turn is built from, in order:

1. ~/Skynet/SKYNET.md — the prompt every agent shares. Edit it in App Settings → System prompt.
2. The agent's CLAUDE.md.
3. The agent's .skynet/SKYNET.md.

Contexts are facts several agents need — "personal", "company". Each is a file in ~/Skynet/context/. Put @context/<name>.md in an agent's .skynet/SKYNET.md and it is included on every turn. Manage them in App Settings → Contexts.

Memory is .skynet/memory/: one fact per file, and MEMORY.md as the index. All three engines read and write the same folder, so what one learns the others know.

Engines and accounts

A chat keeps the engine it started on. New chats and every automation in an agent use the agent's engine (Agent Settings → Engine, or the engine chip).

Chats run in parallel (Agent Settings → Engine) lets every chat in the agent run a turn at the same time, instead of one at a time. Off by default, because all chats share the folder with full write access: two turns can edit the same file or both commit. Turn it on for agents whose chats mostly read and write their own separate files. The app-wide cap of 10 running turns still applies.

An upstream "API Error" is retried after 1, 4 and 10 minutes. While that goes on the run or chat says Retrying in amber, with the reason and the attempt — "Can't reach the API · attempt 3 of 10" while the engine retries inside the turn, "next try 09:15 · attempt 2 of 3" while the app waits to send the turn again. A scheduled run keeps its row under Automations the whole time and is only called failed by the attempt that ends it.

Several Claude accounts

More than one Claude subscription can be signed in at once, and Skynet treats them as one pool. An agent is set to one of them (the engine chip, or Agent Settings → Engine), but when that plan passes 70 % on either bar a turn borrows whichever other account has the most room and goes back when the window resets. The badge in the toolbar always names the account that is actually paying — with ↩︎ when it is borrowing. When every plan is spent the chat is parked: it says so, you get a notification, and it resumes by itself when the plan resets.

Adding one. Settings → Setup → Add & log in: type a short name — it is what you will see in the menus — and a terminal opens with the login running. A name already in use is refused. Once the browser login is done the window checks the email: a login that is already on this Mac (the same account twice is one plan counted as two) is removed again on the spot, and the window says which row has it. A pair added before this check shows amber on Setup, "the same login as …".

Removing one. Remove… on its row in Settings → Setup. Its login is deleted from this Mac's keychain and its folder goes; agents that billed it move to the default login. Nothing changes at Anthropic, so it can be added back any time. The default login cannot be removed there.

By hand, in a terminal:

mkdir -p ~/Skynet/accounts/<name>
CLAUDE_SECURESTORAGE_CONFIG_DIR=~/Skynet/accounts/<name> claude

and /login inside it. Skynet finds it the moment the folder exists; the login is what makes it usable. Every folder under ~/Skynet/accounts/ is an account, and the folder's name is the account's name.

All of this is only for the extra accounts. The default account is a bare claude — the login you already have, in its usual place, with nothing set up and nothing redirected. It has no folder under ~/Skynet/accounts/ and never needs one.

Only the credential is separated, nothing else. CLAUDE_SECURESTORAGE_CONFIG_DIR redirects where the CLI keeps its OAuth token and nothing more, so every account — default and named alike — shares one ~/.claude/: the same settings, skills, MCP config, projects and transcripts. That is why an account's folder stays empty, and why a chat started on one account reads the same as a chat started on another. The only thing that changes is which subscription is billed.

Each machine logs in separately. The credential is not in the folder — the folder stays empty. It is in the login keychain, under Claude Code-credentials for the default account and Claude Code-credentials-<hash> for a named one, where the hash is the first 8 hex of sha256 of the folder's absolute path. So there is nothing to copy across: syncing ~/Skynet/accounts/ copies empty folders, and the keychain item stays behind. On a new Mac, run the two lines above again for each account.

(The item could in principle be moved with security, but only if the path hashes to the same value — which means the same username — and the token it holds is rotated by the CLI anyway. Logging in again is two commands and always correct.)

Which accounts exist is whatever is in ~/Skynet/accounts/ plus the default. Removing an account is removing its folder; the keychain item it used is then unreferenced and can be deleted in Keychain Access, or left alone.

Settings

App Settings (⌘,)

Agent Settings (⌘I)

Done saves Prompt, Engine, Private and Folders. Quickstarts and Automations save as you type.

Quickstarts

One file per button in .skynet/quickstarts/:

---
title: Weekly review
---
Walk me through last week and pull out what actually mattered.

<!--hidden
Read .skynet/context first. Be brief.
-->

title: is the button. The body goes into the message box for you to finish. Anything between a line <!--hidden and a line --> goes to the model with every turn of that chat and is never shown. Optional: order: to sort. The body may be empty if the hidden part says it all — the button then just arms those instructions and leaves the box empty.

Automations

One file per automation in .skynet/automations/:

---
when: weekdays 08:30
name: Standup notes
---
Check my calendar and summarise the day.

when: is schedule words, then a local time:

A prompt runs as a fresh chat of the agent, on its engine, with a note that nobody is watching — questions are declined automatically. If the agent is busy it waits for it — or, with Chats run in parallel on, runs beside it (the same automation never runs twice at once).

A command needs no model at all: add run: and it runs through zsh in the agent's folder, even while the agent is busy. The body is then just notes. Logs go to .skynet/logs/; the last 30 are kept.

---
when: sun 13:00
name: Trend sync
run: cd scripts && bun run sync.ts
---
Weekly pull. Deterministic, so no model needed.

Every few minutes instead of a time. Replace when: with every: — every: 5m, two minutes being the floor — and optionally on: for the days and between: for the hours:

---
every: 10m
on: weekdays
between: 09:00-17:00
name: Inbox sweep
---
Anything in the inbox that needs an answer today?

every: means not oftener than, not "this many times a day": one that comes round while the agent is mid-turn is dropped, not queued — the next one is minutes away and will see whatever is true then. With no between: it fires at 04:00 too.

A pull is the third kind: a check that decides whether the prompt runs at all. Add check: with a command, and

• printing something on stdout means there is something to do — what it printed goes into the prompt,
• printing nothing does nothing: no chat, no notification, no log,
• a non-zero exit means the check is broken — no turn, and the row's dot goes red with the reason.

stderr never counts as output; it goes to the log, so a warning line from a tool cannot be mistaken for news.

---
every: 5m
on: weekdays
between: 09:00-17:00
name: PRs waiting on me
check: ./.skynet/checks/prs.ts
---
A pull request is waiting for my review:

Read the diff, leave review comments, then say in one line what you did.

The check is your own program — write it as a small .ts and run it with bun. It gets the agent's folder as its working directory and the same environment a turn gets, so gh, a skill or a token all resolve. Keeping track of what it has already reported is the check's job, not the app's: print a line per thing that needs doing, keep the ids you have reported in a file of your own, exit 0.

Automations fire only while Skynet is open, and never on a sleeping Mac. A Mac asleep with its lid closed still surfaces for a few seconds every ten minutes or so, and work started there runs in those slices — slowly, and with failed calls. So Skynet starts nothing by itself until the Mac has been awake for three minutes without a break: no automation, no check, no Autopilot task, no retry, no message from Telegram. What came due in the meantime shows as Queued · the Mac was asleep and starts by itself; a key or a click in Skynet starts it at once, because somebody at the Mac means it is awake. What you send from the message box is never held. A turn that was already running when the Mac went to sleep is not stopped. A time missed while the Mac slept still runs later that day; a missed day is not caught up, and an interval simply resumes. Unknown words make the automation invalid and it is skipped — the Automations tab shows it in red.

On an agent's Automations page (the Automations row in its chat list): one row per automation with when it runs and its last run; click one for its runs, with Try in chat, Run now or Check now, and Edit in the header, and a red dot after the name when the last run failed or its check cannot run — fine is silent. Add is top right. A command's runs are its logs.

Autopilot — tasks, plans and the heartbeat

Automations are fixed prompts on a clock. A task is a piece of work an agent does while you are away, and the heartbeat is what keeps it going. Off for every agent until you turn it on: Agent Settings → Autopilot. It is the agent's own — there is no list across agents.

A task is a chat with a status. One markdown file each in .skynet/tasks/: a name: and status: in the header, then two pieces of prose — what to do and why, and under ## Done when, how to tell it is done. The file is the ticket; the chat is the work. A task written by hand needs only that much — drop it in and it is queued:

---
name: Write a haiku file
status: queued
---
Write .skynet/files/haiku.txt holding a three-line haiku about the sea. Nothing else in the file.

## Done when
.skynet/files/haiku.txt exists and has exactly three lines

The app adds the rest as it works — created, by, chat, engine, turns, checks, checker, verdict, note, updated — and plan on a task a planning run proposed. To set an agent up entirely from files: "tasks": true in .skynet/settings.json (with shift, pursue and paused as you like), a .skynet/goal.md, and task files in .skynet/tasks/. Anything you write into a task's chat, whatever its status, puts the agent back to work on it — that is how you answer, send back, or reopen.

The six statuses, in the order a task moves through them. One word each, the same everywhere.

A task with Done when lines is done when the check passes: you wrote the lines, and a fresh turn found every one holds. Review is only for a task with nothing to check. Only the agent asks for Review. The app moves the rest. Dropping exists only before work has started — on a proposal, or on a queued task with no chat.

The agent never checks its own work. When it says it is finished, a fresh chat that has not seen the work reads the "Done when" lines and the folder — running whatever a line needs run — and answers each line with pass or fail. The result appears as a card in the task's chat, and the bar's Check tab opens the checker's own chat, read-only. A pass marks the task Done; a fail sends it back with the finding, and the next turn carries it; the third fail stops it and asks you. A task with no Done when lines has nothing to check and goes to Review, for you to judge.

Nothing waits for a clock. Every event that leaves work to do fires the next step at once: a turn ends and the task is still being worked, so the next turn goes; a check fails, so the fix goes; you press Done, Accept or Resume, so the next queued task is taken, or a plan is made when the queue is empty. Each step does one thing: continue the task being worked, take the next queued one, plan, or nothing. Each nudge sent into a task's chat is a turn. Turn 1 is the task's text; every later one is the same line, "Turn N of 12 — carry on with the task. Say in one line what the next step is", with the check's findings appended when the last check failed. A hidden note on every turn tells the agent the rules: do the next concrete piece, ask one concrete question and stop when it needs you, set review when every Done when line holds, change nothing else in the file. Twelve is a ceiling, not a count to reach — the nudges stop the moment the agent sets review or asks you, which can be turn 1. A task still Working after 12 stops and waits for you, and a message from you starts the count over, which the bar shows as "on your message" while that turn runs. A minute tick is the safety net for what no event covers — the app restarted, a shift beginning (all day, or only the day shift 08:00–18:00 or the night shift 22:00–06:00) — and where the subscription is measured. The Autopilot page's AUTOPILOT line says On (with the shift as a small card when there is one), Off shift, Paused, or Capped with the one reason: the plan's window is spent, the app is at its turn cap, or the subscription is above 75 %, which pauses the heartbeat for an hour. Heartbeat work always runs on the agent's own subscription and never borrows another.

You come first. Writing into any chat of the agent stops an Autopilot turn in progress — a task, a check, a plan — and your message goes the moment it lands; the task stays Working and the next beat carries it on after your turn. Autopilot never takes the agent's turn while a message of yours is waiting for it.

Pause, on the right of that line, stops the whole thing — no turns, no checks, no plans — until you press Resume. The page and the list stay open: you can read, edit, add and accept while it is paused, and the heartbeat carries on from there.

Planning runs when the queue is empty and no proposal is waiting for your decision, and keeps at most 5 tasks open. A task stopped for a word from you, or one in review, does not hold it back. A plan that finds nothing to do is not tried again for four hours.

How a goal ends. Two kinds of goal. One can be met: under the goal, a ## Done when list, like a task's, and a fresh check reads those lines against the folder as the first step of every planning session. Every line holds and the goal is met: no plan, planning stops, you are told, and the shift icon goes grey until you edit the goal. A line fails and the plan runs with what failed as its brief. One never ends — grow the subscriber list — and gets planning sessions per day instead: 1, 2 or 4, each a plan of at most 5 tasks, after which the page says "Planned for today · next 00:00" and what is queued still runs to the end. A goal can have both. Plan now is yours and never counts. A goal with neither has no brake, and the Autopilot tab says so in amber. The GOAL block on the page shows the Done when lines with the last check's verdict on each. The PLANNING line says when the next plan comes and why not sooner: "Next when the queue is empty", "Next when you decide · 2 proposed", "Next when a task finishes · 5 open", "Next in 3 h · the last plan found nothing to do", "Planning now". Plan now at its end runs one on demand. The Tasks | Plans switch at the top right of the Autopilot page shows the plans instead of the tasks: one row per planning chat with what set it off, how many it proposed, how many you accepted and dropped, and when. A row opens that chat; "Autopilot ›" in its bar comes back.

Where tasks show.

• The chat list has three sections, a line between each: Automations, Autopilot (when it is on), then your chats — New chat, search, the list by day. An automation's runs and a task's chats are not in the list; they live under their section. A run you write into becomes one of your chats: from your first message it is listed with the rest, with a clock beside it to say an automation started it, and it stays under its automation too.
• Automations is the inbox for scheduled work: what is running or queued, and every run that finished while you were away, with an amber dot (ran) or a red dot (failed) until you open it. A run is one row for as long as it is open: while its turn has ended and background work is still out it stays Running, with the hollow ring and how long that work has been going, and becomes Ran when the work has reported. A broken check stays red until it is fixed. The row's clock is green when the agent has any automations and grey when it has none; it carries how many in a small pill; its amber count is the unseen runs, and its mark the worst of them. Click the row for the agent's Automations page — one row per automation with when it runs and its last run; click one for its runs, click a run for its chat, which carries an "Automations ›" bar back. Add is on the page.
• Autopilot holds only what waits for you, what is ready to review, what is being worked, and a planning run while it runs. Its icon is the shift — sun, moon or ∞, green on shift, amber paused, grey off shift — and after the label sits the mode when the queue runs empty. Its count is what waits on you — waiting, review, proposed — and its mark the worst of them. Task chats are not in the chat list at all — done ones included — the Autopilot page is where they are. A line under the section says so in amber when Autopilot is paused, off shift or capped. Its row opens the agent's Autopilot page; Add is on the page.
• The Autopilot page: the goal, the Autopilot line with Pause and the planning line with Plan now, then one table with a filter per status — glyph, name, from, status, check, when. It is for overview and navigation: a task with a chat opens its chat; a proposal or a queued task with no chat opens as a sheet with the task, its Done when, and Accept, Start now, Move to top or Drop.
• A task's chat carries a bar at the top: "Autopilot ›" when you came from the list, the name, three tabs — Task with the brief and its Done when lines, read-only, the facts — status, from, created, turns, check — a line for the state, and Open the file, so the text is one click away at every stage; Chat with the task's status; Check with the check's verdict (Pass · 3 of 3, Fail · 1 of 3, Checking) — and the actions: Pause while Working; Back to the queue and Done while Waiting; Done in Review; Move to top and Start now on a paused task. Under it, the turn count and when. The Check tab shows the checker's own chat, read-only; Chat brings you back. The message box's placeholder says what writing does in that state. Make this a task on any chat's right-click hands that conversation to the heartbeat.
• Add is two boxes: the task, and how to check it. The first line of the task is its name. A task that is only a name is still a whole task: the agent does what the name asks and decides what done looks like. A proposed or queued task opens the same two boxes, editable, as a sheet.

The Autopilot tab: the switch, the goal and its Done when (.skynet/goal.md, the lines under ## Done when, with the same @ and / menus as the prompt), planning sessions per day, when it runs (All day · Day shift · Night shift), and the mode when the queue is empty: Stop goes quiet until you add or accept a task; Pursue goal — plan, wait for approval runs a planning chat that proposes tasks for you to accept; Pursue goal — plan and execute, no approval starts them on its own, never more than 5 open.

Links

The toolbar's link chips come from .skynet/links.md — every [title](url) in it, in the order written:

[staging](https://staging.example.com)
[board](https://trello.com/b/abc)
browser: system

browser: system opens them in your own browser; the default is the shared browser (Brave or Chrome, see Setup → Agent browser). Right-click a chip to open it in the other one, once.

With no links.md, a folder with .skynet/box.yml gets its development box's addresses instead — its public ngrok names (https://<name>.ngrok.dev, https://<name>-api.ngrok.dev, …) when the file has an ngrok: line, otherwise its .localhost ones.

Sources — the @ menu

Every file in ~/Skynet/sources/ is one source in the @ menu, shared by all agents:

---
name: jira
detail: open tickets
min: 2
insert: [jira:{key}]
run: ~/.claude/skills/jira/jira search "$QUERY" --json
---
Notes for whoever opens this file.

What you type reaches the command as $QUERY, and a reference as $REF — in the environment, never pasted into the command, so nothing needs escaping. A source whose command is a path that doesn't exist on this Mac is left out of the menu. A file with only ref: is a resolver: it draws cards but never appears in the menu.

Check them all at once from Terminal:

/Applications/Skynet.app/Contents/MacOS/skynet-mac --sources "roadmap"

References and cards

Anything in a reply that a source claims — [notion:…], [bear:…], [channel:…] — becomes a card with its real title. So do absolute file paths that exist, and plain web addresses. A path into an app's folder is a card for the app: its icon, whether it runs, and a click opens it in a window of its own (see Apps). A file an agent writes in the turn gets a card too. Click to open; right-click for Quick Look, Show in Finder, Copy reference.

Background work and notifications

A claude turn can leave work running — background commands, subagents, schedules. The chat shows a hollow ring and the task chip; when the work finishes, the chat wakes by itself and you get a notification.

Quitting ends that running work — and anything an agent started and left running, such as a server — and it is not restarted on the next launch — so while any agent has a turn or background work running, ⌘Q asks first. Keep Working is the default; Quit Anyway quits. Your chats are not lost: every one is on disk and back in the chat list on the next launch, ready to continue — only the work that was still running is gone. A script can skip the question with tell application id "dev.hannisdal.skynet-mac" to quit saving no.

Notifications come when an automation starts, finishes or fails; when an agent asks you something while you are elsewhere; when a task needs you, is ready to review, is done or has stalled; when background work finishes; when a chat is parked on a plan limit or gives up retrying; and when a new version of Skynet is out. Clicking one opens the chat.

Quitting Skynet ends every session and everything running in them.

Activity

⌘S. One table, a row per agent that has anything at all: a turn running, tasks on its Autopilot, or automations on its clock. Running rows first, then what waits on you, then whose clock fires soonest.

• NOW — a pulse and how many things run; a hand and how many wait on you. Click it for the running chat.
• AUTOPILOT — the shift (sun for day, moon for night, ∞ for always; green while on shift and free to work, amber while paused or capped, grey off shift), the mode when its queue runs empty (nothing for Stop, a person-with-check for plans you approve, a bolt for plans that start on their own) and one bar of its open tasks, left to right queued, working, needs you, with the total. Click it for the Autopilot page.
• AUTOMATIONS — the count in a pill with the section's clock, the clock red when a last run failed or a check cannot run, amber when one is queued, green while one runs; then the next fire. Click it for the Automations page.
• Each cell is its own link, and says so: the one under the pointer greys like a button, and a cell with nothing in it stays flat. The agent's name opens the agent.
• The header is the app's turn cap — how many top-level turns run, of the 10 it runs at once — and each subscription drawn as the usage popover draws it: a thin column per window, the highest number beside them.

Dashboard

⌘0. Panels are defined in ~/Skynet/dashboard/dashboard.json:

{"panels": [
  {"id": "clock", "title": "Clock", "run": "bun panels/clock.ts"},
  {"id": "notes", "title": "Notes", "file": "notes.html"}
]}

The toolbar's Zed (</>), Terminal and Finder open that folder, as an agent's do.

The dot at the right of each panel, beside its ↻, speaks the sidebar's language: a pulsing green dot while it refreshes, amber when it has been updated since you last looked at it (opening it clears that), red when its last run failed — hover for the error — and grey when it has never run. A panel that is fine and already seen has no dot.

The look. Panels, apps and the pages agents write all share one stylesheet that comes with Skynet — its colours light and dark, type, tables, forms, dialogs and six chart colours. A panel gets it by linking ../style.css; style.css in the dashboard folder holds only your own additions, which come after it and win. An app and an agent read its path from SKYNET_STYLE. It is a default: a page's own CSS always wins, and a page without it still works. (A style.css from before this, which held the whole sheet, is set aside as style.before-skynet-css.css at launch.)

run: is a command that prints HTML (cached, refreshed with ↻ or Update all); file: is an HTML file in the dashboard folder. Anything with buttons, input or its own data is an app instead (see Apps); an old serve: panel is left out. Optional: timeout (seconds, default 30), js (allow JavaScript), owner (an agent's name — it decides the panel's section, and the selected panel shows it at the top of the page). A link to ?k=v in a panel re-runs its command with that in QUERY_STRING.

Sections. A panel sits where its owner sits in the sidebar: under Favourites when the owner is a favourite, under the owner's group otherwise, and under Other panels when it has no owner or the owner is not an agent here. A section shows only while it has panels; with no favourites and no groups the list has no headers at all. Sections fold like the sidebar's, but on their own — folding one here does not fold it there. A folded section keeps the panel you have open in view, and shows a red dot when a panel in it failed its last run, the green pulse while one is refreshing, and otherwise an amber one when one has been updated since you looked. Right-click a header for Collapse All and Expand All.

Latest / A–Z sits on the line at the top of the list and orders every section, Favourites included: Latest puts the panel updated last on top. Groups, at the left end of that line, switches the sections off and on, on its own setting: grey lists every panel in one run with no headers — Favourites included, unlike the sidebar — and green puts the sections back. It shows when there are favourites or groups.

Teams. Panels a teammate published to one of your teams are listed under Teams › Panels; the ones you press Add to Dashboard on appear here too, read-only, with a small team mark, who sent them and when. With Groups on each such team has its own section (its name with the team mark); with Groups off they sit in the one list, their badge saying who and which team. One that has not changed for a week turns amber. To publish one of yours, select a static panel (a file:) and press Publish… beside Update all; once published the button says Published to …, and its menu has Unpublish. What you publish belongs to the account that published it: signed in as another account on the same Mac, the panel says Published to … by that account, and only that account can update or unpublish it. Signing out takes nothing down — what you published keeps running; this Mac just stops showing it as yours until you sign in again. Teammates see exactly that page, its stylesheet included, and it changes on their Mac within a minute of the file changing on yours. A run: panel cannot be published — its numbers come from your keys — so a dynamic panel travels inside a skill instead (see Teams, Skills).

Right-click a panel for Update Now (a run: panel) and Belongs to › — the same menu as the agent's name beside Update all when the panel is selected — which sets its owner: the sidebar's sections, each opening onto its agents, and No Agent. The section the panel lands in opens, and the panel stays selected. It writes owner in dashboard.json. The page also notices when that file changes while it is showing, so a panel an agent adds appears at once.

Apps

An app is a small web app an agent built for you — an expense tracker, a workout log, a form to fill in each week — that runs on this Mac only. Ask any agent for one ("make me an expense tracker app"); it uses the skynet-apps skill, and its reply carries the app's card.

Studio in the sidebar has two tabs: Apps, and Artifacts — the pages and files your agents published to a link (see Teams, the last paragraph). An app is a folder in the agent's own folder, apps/<name>/, with an app.json (title, run, icon) beside its code; whatever it stores stays in that folder too. icon is the name of an icon from the same set agents use (wallet, inbox) — drawn like an agent's mark in the app's own colour, but square — or an emoji, as before. The Apps tab lists every agent's apps — icon, name and whether it runs — and runs the one you select beside the list.

• Opening an app starts it (Skynet hands it a free port in PORT, on 127.0.0.1); it stops five minutes after nothing showed it, and its data stays. An open window counts as showing it.
• The agent that made an app shows at the top of it, beside Open in window — its mark and name; click it to go to that agent's chats.
• Open in window, on the page or by clicking its card in a chat, gives it a window of its own, so you can use it beside the chat. While it has one, the page shows it there instead of a second copy — Show window brings the window forward, Bring it back here closes it and the app returns to the page. Stop stops it now, and it stays stopped until you open it or press Start.
• When its code changes — the agent editing it — it restarts and reloads by itself, a crashed one included, so a fix shows without pressing anything.
• If it crashes you see its last lines, Start again, and Ask … to fix it, which puts the error in its agent's message box.
• alert(), confirm() and prompt() in an app show as sheets, file inputs as an open panel, and links to new tabs open in your browser.
• The ··· menu (or right-click in the list): Open in Window, Show in Finder, Ask … to Change It.
• Apps still running when Skynet is force-quit are stopped the next time it starts.

Skills

Skills in the sidebar, with three tabs — a skill is in exactly one of them:

Each tab is one list, A–Z, with anything that needs you first; All sources narrows Installed and Discover to one source. A card's chip says where it came from (Skynet, Ola · Quantfolio, Plugin, or Shared · Quantfolio on your own). Its badge says where it stands, and only when there is something to say. Each status has one word and one colour — on the card, on its filter chip and in the sheet: amber Not set up and Not tested, red Test failed, green Testing, Tested and Update. A filter chip with nothing in it is hidden. An amber dot on the sidebar row means one of your skills is not set up, not tested or failed its test. An agent's own skills, in its folder's .claude/skills, are not listed here.

A card opens the skill's sheet (Esc closes it):

• 1 · Set up lists what the skill needs, one row each, with whether this Mac has it. A skill says what it needs in its own SKILL.md, under needs: — one line per thing, the kind first: key, connection, login, install, permission, step, running, fill-in, then the name and, after a dash, a note on where to find it. A skill that says nothing still shows the keys in its .env and the placeholders in its Placeholders list. A key is typed straight into the row and saved in the skill's own .env (mode 600, handed to claude, codex and pi alike); a plain value shows as itself, a secret as dots. An install that is missing has Copy for the command — Skynet never installs anything itself. A permission, a step on a vendor's site, or something that has to be running cannot be seen from here; the test finds out.
• 2 · Test runs the skill's own example: — or anything you type instead — as one real turn on the engine you pick (the one your agent runs on, unless you choose another). It runs in ~/Skynet/skill-tests/<skill>, outside your agents: it is in no chat list. Passed means the turn finished, the engine could reach the skill, and no tool call failed — the app decides, not a model. The steps show under it as they happen, then the answer. Closing the sheet does not stop a test. The test needs the setup done first, and it uses your real accounts — examples only read.
• SKILL.md is the skill itself, saved as you type. Files lists what is in its folder.
• Uninstall…, on an installed skill, moves its folder — keys and all — to the Trash after asking, and forgets its test results.

A card in Discover shows what the skill will need and the test it will run before anything is installed. Install puts it in ~/.claude/skills/<name> for every agent, moves it to Installed and opens it at 1 · Set up. Installing from the Teams page does the same. A newer version shows as Update on the Installed card; taking it keeps your keys and what was filled in.

Connections. Add connection… takes a name, the server's address (the vendor's docs call it the MCP URL) and how it signs in: Login in the browser opens your browser once and comes back by itself; A key asks for the key the vendor gave you; No login is for a server that asks for nothing, like an app running on this Mac. A connection has the same two steps as a skill: 1 · Set up (sign in, the key, or whether it answers) and 2 · Test, which signs in with what Skynet holds, shakes hands and asks the server for its tools — nothing that could change anything. Skynet runs that test by itself, in the background, for every connection that is set up and has not been tested for a day — so a login a vendor quietly ended shows up on its own. It is ready once the test has passed, with the same badges as skills: Not set up when the login ended or it does not answer, Not tested, Test failed, Tested. The sheet lists the tools it offers; Sign out forgets the login, Remove… the whole connection. A skill whose connection is not signed in has Sign in… right in its own setup. Agents call it with ~/.claude/skills/skynet-mcp/skynet-mcp call <server> <tool> '<json>'.

Use Connections, not each engine's own MCP setup. claude, codex and pi can each add an MCP server themselves (claude mcp add, /mcp, a .mcp.json), but each keeps that login inside its own account — sign in to another Claude subscription, or switch engine, and the tools quietly stop working, or differ from one agent to the next. A server added under Connections is held by Skynet once and works the same for every agent, on every engine and every account. Skynet tells its agents so: they reach your connections through the built-in skynet-mcp skill and never add a server of their own. Already added one the engines' way? Add it under Connections and remove it from the engine.

Keys used to have their own Settings tab; they live on their skill now.

Teams

Teams in the sidebar. Sign in with your email — that is the whole first screen, and any address works. Email me a sign-in link sends a link from hello@skynetapp.eu; press Finish signing in on the page it opens, from any browser, the phone included, and this page moves on by itself. Asked more than once? Any of the links works; Send it again works once every 30 seconds. A team's invite code joins that team. The address you typed last is filled in for you. The account is only for Teams and publishing — Skynet itself never needs one.

The team selector, the team's name beside the Teams title, switches teams, takes an invite code to join another one (free, on the trial too), and starts a New team (that needs a key — on the trial, Get a key… opens Settings › Licence). Your email at the top right opens Sign out — there with or without a team. Whoever creates a team owns it; everyone else is a member. Nothing else: no admins, no viewers.

Artifacts — the second tab under Studio — is yours, not a team's, and there before you join or start one: everything your agents published, with Copy link, Open and Delete, and when each link stops working. An agent can publish a finished file, or a folder with index.html and its own images and CSS, to a long secret link on a.skynetapp.eu — through the built-in skynet-artifacts skill, which Skynet writes to ~/.claude/skills/ at launch. The link shows up in the chat as a card with the title and when it expires; right-click it for Copy Link. Anyone with the link can open it, with no login; publishing needs this Mac signed in, and a key — on the trial it is refused and the file stays on the Mac. With the id the agent can update it — same link, new content. A link is gone 90 days after its last update, or as soon as you Delete it under Studio › Artifacts. Agents never delete.

Licence and trial

The licence is a key on this Mac — no account. Every Mac gets a 30-day trial the first time Skynet opens, one per Mac (a reinstall does not start a new one); a trial gets every update. Buy — €99 (once, VAT included) opens Paddle's checkout inside the app; when it is paid the key is put on this Mac and emailed to the address you gave Paddle. The key works offline, on any of your Macs: on another Mac, Settings › Licence › Enter a key… and paste all of it from the email. A key gives 24 months of updates; after that Skynet keeps working on the version you have. Redeem a code… takes a code you were given, with your email, and makes you a key for life.

When the trial is over and there is no key, Skynet shows a window of its own with the same three choices; your agents, chats and files stay on the Mac, and scheduled automations wait.

The cloud is separate: an account, only for Teams and publishing. Signing in (Teams page — your email, then the link we send) has nothing to do with the licence; Sign out stops Teams and publishing on this Mac and nothing else. Joining a team is free, on the trial too. Creating a team and publishing artifacts need a key.

Telegram

Your agents, from Telegram on a phone. What you write to your own bot goes to an agent as a message; its answer comes back while it is being written, its questions arrive as buttons, and files it names in a reply are sent as files. The agent runs on this Mac in its own folder, on its own engine — claude, codex or pi — and the chat is in its chat list like any other.

Set it up on the Telegram page (⌘T, or the sidebar):

1. In Telegram, open @BotFather, send /newbot, and give the bot a name and a username ending in bot.
2. Paste the token BotFather answers with, and press Connect.
3. Skynet shows a six-digit code. Send it to your bot. From then on the bot answers you and nobody else.

You can also just ask for another agent — "switch to chat", typed or in a voice note. The agent you are talking to understands it and moves the phone over, and the bot says "Now talking to chat."

A question can be answered by its button or by writing the answer; writing back to a permission question is a no, with your reason. An answer from an agent other than the one you are talking to starts with that agent's name. Files go to the phone up to 50 MB.

Keep this Mac awake, on the Telegram page, stops the Mac going to sleep while Telegram is on — a sleeping Mac answers nobody. A message that reaches a Mac which is asleep anyway — on battery, or with the lid closed — is kept, and the phone is told so: the agent starts on it once the Mac has been awake for three minutes. It holds only on the power adapter, never on battery; the display still turns off; and closing the lid still puts the Mac to sleep, unless an external display is connected.

Telegram's servers see what is sent. Leave it off for anything that must not leave the Mac. It works while Skynet is open; what you send while it is closed waits at Telegram for a day. Pair another phone forgets yours and shows a new code; Disconnect removes the token.

Two Macs

Skynet on two Macs — a Mac mini that never sleeps and a MacBook, say — is two independent Skynets. That is the shape that works:

• Signed in on both is fine. Each Mac signs in with its own link and keeps its own session; nothing assumes one Mac.
• Telegram belongs to one of them. Telegram allows a single reader per bot: a second Mac on the same token fights the first, and a message lands on whichever Mac happens to be listening. Connect the bot on the always-on Mac and leave the other without it.
• Keep ~/Skynet out of cloud folders. It is this Mac's live state — which automations ran, what is unread, where the bot left off — and the chats are not in it anyway: every engine keeps them per Mac. Two Macs sharing it get conflict copies and automations that run twice.

One agent can travel. An agent is any folder, so a single agent can live in Dropbox and be added on both Macs, carrying its prompt, settings, memory and files with it. Three rules: its chats are still per Mac, so each side shows its own conversations; use it from one Mac at a time — two turns at once write the same files; and its automations run on every Mac that has it, so keep them on the always-on one. Dropbox rather than iCloud, which can leave a file undownloaded just when the agent goes to read it.

Search

⌘F searches what was said in every chat of every agent — claude, codex and pi — plus the archive in ~/Skynet/chatlogs/. Press ⏎. Every word has to appear in the same chat; tool output and pasted files are not searched. Up to 200 hits, newest first. ⌘K searches only the agent you are in.

Updates and versions

Versions read R12-2026-09-10: the release number, one more each time, and the day it went out. A copy built from source says R12-dev. About Skynet shows yours.

Skynet checks the website once a day. When there is a newer release it asks you once, in a dialog (the Dock icon bounces if Skynet is in the background); Later means not again for that release; Check for Updates… in the Skynet menu asks now. Install and Relaunch downloads it, checks that it is signed by H5 Innovations, replaces the app and opens it again — after warning you if any chats are working, since quitting stops them. If anything fails, the app you have stays as it was and the website is one click away. Copies built from source never check on their own.

The website counts that daily check, each download and each update, by build number and nothing else — no address and no identifier of your Mac is kept. That is how the people who make Skynet know how many copies are in use.

Feedback

Help → Send Feedback…, or Send Feedback… beside the search at the top of this guide, opens a box for a bug, something confusing, or something you wish Skynet did, with an optional email if you would like an answer. It goes to the people who make Skynet together with your Skynet and macOS versions — nothing else: no chat, no file, no agent name.

An agent can send it for you too. Skynet keeps a skill, skynet-feedback, in ~/.claude/skills/ — every engine sees it — so "tell the Skynet developers the chat list jumps when…" in any chat works: the agent shows you the text and sends it when you say so. The skill runs skynet-mac --feedback "<text>", and Skynet writes it again at every launch, so an edit to it does not last.

The download on the website is a disk image: open it and drag Skynet onto Applications. It is signed and notarized by Apple.

Files in ~/Skynet

From the terminal

The app's binary answers a few questions without opening a window:

S=/Applications/Skynet.app/Contents/MacOS/skynet-mac
$S --links          # every agent's link chips and where they open
$S --sources "q"    # run every @ source once and show what came back
$S --quickstarts    # every agent's quickstarts
$S --automations    # every agent's automations, their schedule and state
$S --tasks          # every agent's tasks, their status and chat, and the last heartbeat
$S --artifacts publish <file-or-folder> [--title "…"]   # what the skynet-artifacts skill runs
$S --artifacts update <id> <file-or-folder>             # same link, new content
$S --artifacts list