Install it like a real app

Every GitHub release now ships packages for Arch/Omarchy, Debian 13 and Fedora 42, with a desktop entry. The easiest path keeps it updated for you:

autonomix-cli add https://github.com/ninepointlabs/rune

The everyday editor filled in

• A File menu with save-button states and autosave.
• Font and text-color pickers, and a toolbar that fits any window: Table and alignment menus, with a ⋯ overflow for the rest.
• A Table menu: insert rows and columns, delete a table.
• A command palette on Ctrl+K.
• Pages and margins: a real page view, Page setup, and paper size picked from your locale.
• Headers and footers edited in place, with page number and page count fields that round-trip through both ODF and .docx.

Rune writes its own ODF now

Rune used to lean on Qt’s document writer, and it kept losing things: headings saved as bold text, nested tables lost content, a table after a list could vanish. Rune now writes the whole .odt itself: real Heading 1–6 styles, links, lists that keep their numbering across interruptions, and tables with widths, borders, merged cells and nesting. If ODF is the home format, Rune has to be a good citizen of it, and now it is one.

Tools for people writing long things

0.8.3 added author tooling:

• Headings from the toolbar (Ctrl+Alt+0–3) and an outline sidebar with chapters, scenes and word counts. Drag a section to move it in one undo step.
• Story notes saved inside the file.
• Sources from a form, CSL-JSON or BibTeX, with citations (Ctrl+Shift+C) in APA 7, MLA 9, Chicago author-date or IEEE, and a bibliography that keeps up with every edit.

Citations survive a trip through .docx. Word and LibreOffice see the text, and Rune finds the citations again when the file comes back.

AI edits that don’t wreck your paragraphs

The AI can read your notes and sources, cite with [@key], and add sources, which are marked unreviewed until you check them. 0.8.4 fixed a nasty one: models copied 80-column line wraps into their edits, and every wrap became a paragraph break. The context now goes out one paragraph per line, and slightly garbled quotes still match. The same edit came out clean in 15 of 15 live ChatGPT runs, where every run checked before had broken paragraphs.

See it first

The site now has screenshots, a narrated 1:47 demo recorded from the real app, and a seven-page how-to guide covering formatting, pages, the AI, writing a book, and citations. Under all of it are 487 automated checks.

ODF by default still holds. The difference now is that Rune gives you a real reason to choose it.

An MCP server on stdio

speakeasy mcp speaks the Model Context Protocol over standard input and output. No network port, no daemon to babysit. Point Claude Code, Grok Bot, Hermes, or any other MCP client at the binary and it gets four tools:

• list_agents — which agents are installed and visible, with models and effort levels
• find_repo — where a GitHub repo is checked out on this machine
• create_task — start a task with title, description, agent, and optional model, effort, and repo or folder
• list_tasks — what is already running, so a bot does not start a duplicate

A bot watching your repos can pick Claude or Codex, write the brief, and park the job in the right local checkout. It shows up in your Speakeasy list like anything you started yourself. The client’s name is stored as the task’s origin, and Speakeasy leaves your new-task picker defaults alone.

Approvals stay yours

The MCP path deliberately cannot pass extra agent arguments, so a bot cannot flip permission prompts off. It also cannot peek at a task’s screen, type into it, or stop it. The agent still asks you before risky actions; you still answer.

find_repo strips credentials out of remote URLs before it reports them. Add the MCP server only to clients you trust, same as you would any tool that can start processes in your project folders.

Titles and prompts off the process list

0.3.1 closes a quieter hole. The Omarchy panel used to put the task title and description on the speakeasy new command line, where any other user on the machine could read them with ps. They now go over stdin as one line of JSON (--stdin-json). The CLI already avoided stuffing prompts into argv for normal use; the panel catches up.

Try it

speakeasy mcp
# or wire it into Claude Code:
claude mcp add speakeasy -- ~/.local/bin/speakeasy mcp

Upgrade with your usual Omarchy plugin path, or pull ninepointlabs/speakeasy and run ./install.sh. If your workflow is “bot finds the problem, I approve the fix,” Speakeasy is now the handoff.

Kestrel is a Rust CLI that posts to X (Twitter) and doubles as an MCP server so AI agents can post through it. The killer feature: a hard daily post limit, shared between the CLI and the MCP server. Your agent might be chatty, but Kestrel knows when to say “that’s enough for today.”

Two modes, one binary

From the terminal, it is dead simple:

kestrel post "Hello world"
kestrel post "check this out" --image ./photo.png
kestrel status         # Posts today: 3/50 (6%)

Fire up the MCP server with kestrel serve and suddenly Claude Code, Claude Desktop, or Hermes can post on your behalf with exactly the same guardrails. No separate config, no backdoor. If the daily limit is hit, the MCP tool returns an error result instead of posting. Your credit card stays safe.

The economics of X posting in 2026

Here is the part that makes Kestrel genuinely useful instead of just fun. Since February 2026, X’s API is pay-per-use with no free tier. Every post costs real money:

• Plain text tweet: $0.015
• Tweet with a URL: $0.200 (yes, 13x more)
• Summoned reply: $0.010

A link surcharge that steep means one careless agent posting URLs could run up a bill fast. Kestrel’s daily limit is your safety net. At 50 posts per day, plain text costs $22.50/month. With links mixed in at 30%, that jumps to $90/month. Kestrel makes sure you know exactly where you stand.

Built to be boring (in the best way)

The config lives in ~/.config/kestrel/config.toml with 0600 permissions. State is tracked in a tiny JSON file that resets at midnight local time. One binary, one config file, one state file. No daemon, no database, no cloud service. It works the same whether you type kestrel post or your AI agent does.

The MCP server exposes exactly two tools: kestrel_post and kestrel_status. That is it. No read access, no timeline scraping, no DMs. Kestrel is built for one job and it does not overreach.

Worth a look if

You post from the terminal, you run AI agents that need controlled X access, or you just appreciate a well-scoped Rust tool that respects your wallet. The repo has a clear README with pricing tables, troubleshooting guides for every HTTP error code, and a one-command install via cargo install --path ..

Here’s the thing I had to talk myself out of first.

My first instinct was to make DOCX a first-class format alongside ODF, because it’s convenient. DOCX is what the business world runs on, it’s what shows up in every email attachment, and treating it as a second-tier citizen felt like making life harder for anyone who has to interoperate with the rest of the planet. That instinct was really just me optimizing for my own convenience, not for what Rune should actually be.

Then I looked honestly at how often I actually create documents that need to be DOCX. Rarely. Almost never, really. Most of what I write doesn’t care what the underlying format is, it cares about being readable, editable, and not locked to one vendor’s whims. The cases where DOCX truly matters are the cases where I’m handing something to someone else’s pipeline, and for that, export now and again is plenty.

So that settled it for me: if ODF is ever going to get real traction, and if we actually want to see the world move away from a single-vendor format as the default assumption, somebody has to stop treating DOCX as equal. Every tool that makes DOCX the comfortable default, even a little, is one more vote for the status quo. Rune is my vote the other way. ODF is home. DOCX is a well-supported guest, not a roommate.

The “well-supported” part matters, because I’m not interested in making DOCX support bad out of principle. Nobody wins if opening a .docx in Rune mangles someone’s formatting. So on the backend, DOCX import and export runs through the LibreOffice engine. LibreOffice has put in literally decades of work getting that conversion right, through every quirky OOXML edge case Microsoft has shipped over the years. There’s no reason for me to reinvent that wheel badly when I can lean on work that’s already excellent. Rune gets to stay focused on being a genuinely good ODF-native editor, and the DOCX bridge gets to be solid because someone else already paid the tuition for that problem.

That’s the shape of it: ODF by default, DOCX by door, LibreOffice doing the heavy lifting at the threshold. If you want to see where Rune is headed, rune.ninepointlabs.com has more.

That’s fixed now. Autonomix just picked up a real check and update command, and on Omarchy it hooks straight into the system updater, so your GitHub-sourced apps get refreshed in the same breath as everything else.

What’s new

• autonomix-cli check lists every tracked app with an update available, no TUI required.
• autonomix-cli update [-y] installs those updates non-interactively, the -y flag skips the confirmation prompt entirely.
• It only touches apps installed through your actual package manager (dpkg, rpm, pacman). Anything living as a loose binary on PATH, or managed through Flatpak/Snap, gets reported and left alone, because blindly overwriting those is how you break things.
• --version and --help now behave like every other CLI instead of falling through to the TUI.
• Set GITHUB_TOKEN (or GH_TOKEN) if you’re tracking enough repos to hit GitHub’s 60-requests-an-hour API limit; it bumps you to 5,000.

The Omarchy part

This is the fun bit. Drop the included hook into Omarchy’s update pipeline and Autonomix updates ride along for free every time you run omarchy update:

install -m755 contrib/omarchy/autonomix.hook ~/.config/omarchy/hooks/post-update.d/autonomix.hook

That’s it. One omarchy update now refreshes your system packages and whatever you’re tracking through Autonomix, no separate step to remember.

Autonomix CLI on GitHub →

Grab the latest release, or if you’re already on it, go build and you’re there. If you haven’t tried Autonomix at all yet, the first post has the full rundown.

Jubako on GitHub | jubako.ninepointlabs.com

Jubako (pronounced joo-bah-koh, named after the stacked Japanese lunch boxes) is a simple desktop database for Omarchy Linux. One file, several tables, no SQL required. Think of it as the spirit of old-school Microsoft Access, reimagined for people who would rather get things done than learn a query language.

Drop a Spreadsheet, Get a Database

The killer feature is the import. Drag a CSV or Excel file onto the window and Jubako figures out what each column is – words, whole numbers, decimals, dates, yes/no values. It shows you its best guesses before writing anything, so you can correct a column that got tagged as “words” when it’s really a date column. A multi-sheet workbook becomes one table per sheet. No ceremony, no setup.

Once your data is in, you can browse it as a grid, type row-by-row in a form, filter with rules like “Status is not Delivered AND Total over 100,” and save those filters as named views. Need to print? The report designer gives you a live preview, groups rows with subtotals, and exports to PDF. Your spreadsheet just grew up.

Your AI Agent Can Drive It Too

Jubako ships with an MCP server, which means Claude Code (or any MCP-capable agent) can do everything the app can do. “Take this spreadsheet and make me a database” works as a natural-language command. The tools cover the full surface: create databases, import spreadsheets, list and filter rows, add and update records, design reports, export to CSV or Excel or PDF. Twenty-seven tools in total, all over stdio.

Safety is taken seriously: file paths are checked against approved folders, spreadsheet formulas are never executed, server passwords are never saved, and destructive operations ask first.

Under the Hood

Jubako is a Qt Quick desktop app with a Python core. By default your database is a single SQLite file (.jubadb) in your Documents folder – copy it, back it up, email it. If you already run PostgreSQL or MySQL, you can point Jubako at that instead. The app follows your Omarchy theme, light or dark, and changes with it when you switch.

Installation is one command on Arch/Omarchy, Debian, or Fedora – packages are on the releases page. Or clone the repo and run from source. It’s MIT-licensed and actively developed, with a growing test suite that covers type guessing, path safety, CSV and Excel import/export, reports, and the MCP server.

If your spreadsheets have been quietly running your life, Jubako is a clean upgrade. Same data, less chaos, and a lunch box metaphor you didn’t know you needed.

Jubako on GitHub

Ideas on GitHub is the smallest possible answer to that problem. It’s a single Go binary that appends numbered ideas to a markdown file. No database, no daemon, no web UI. Just idea "your thought here" and you’re back to work.

How it works

idea "Add retry logic to the API client"
idea "Switch the blog to folderblog instead of Hugo"
idea "Write a cron job that posts a daily project highlight"

Each one gets the next number. When you want to see them:

idea -l

And when you’ve actually done the thing, or decided it was a terrible idea after all:

idea -r 2         # remove idea 2
idea -r 1-3       # remove ideas 1 through 3
idea -r 1,5,9     # remove specific ones

After removal, the remaining ideas renumber themselves from 1. It’s all atomic, too: if any number in your range is invalid, nothing gets removed. No half-done cleanups.

Why it’s great

It’s written in Go with zero dependencies beyond the standard library. The binary is small, the build is instant, and the storage format is just a markdown file under a # Ideas heading in ~/Documents/Ideas/ideas.md. You can point it anywhere with IDEAS_FILE if you want per-project idea files. There’s nothing to break, nothing to upgrade, and nothing to regret installing.

Sometimes the best tool is the one that does exactly one thing and then gets out of your way. Ideas doesn’t try to be Notion. It doesn’t try to organize, categorize, prioritize, or remind. It just writes down the thing you thought of so you can get back to the thing you were doing.

Install

git clone https://github.com/ninepointlabs/ideas.git
cd ideas
make build
sudo make install

That’s it. idea lands in /usr/local/bin and you’re ready to stop losing thoughts to the void.

Grab it at github.com/ninepointlabs/ideas and give your stray thoughts a home.

That’s folderblog. And it actually delivers.

folderblog on GitHub →  |  Website & video tour →

A folder is a blog

folderblog is a single Rust binary that runs quietly in the background, watching ~/Blogs. Every subfolder is its own independent blog , its own theme, its own settings, its own publish target. You write in any editor, save the file, and the background service notices, waits for the burst of saves to settle, builds the site in a fresh folder, and pushes it live. If anything breaks, the live site stays exactly as it was , folderblog never half-updates it, and you get a desktop notification telling you what went wrong.

GitHub Pages works with zero ongoing clicks. Log in once, and folderblog new myblog creates the repository, turns on Pages, and publishes your first post. Custom domains too , it even prints the DNS records you need. Not a GitHub person? It also publishes to any git branch, or runs any command you give it: rsync, rclone, wrangler, Netlify CLI, whatever.

Themes with no ceiling

folderblog’s engine handles content, feeds, and sitemaps. Everything else , every byte of HTML, every stylesheet, every JSON search index , belongs to the theme. Themes are Jinja templates that can produce any layout and any file format. One template can render tag pages, year archives, paginated series. A theme can even generate its own search index.

To prove the engine doesn’t interfere, we gave three coding agents the same blog, its AGENTS.md contract, and a one-line design brief. None of them needed a change to the engine. The screenshots in this post? Same blog, four different themes, all agent-built.

The little things that make it good

Posts don’t need front matter. The title comes from your first heading, the address from the filename, the date from when folderblog first saw it , recorded once, so editing or syncing never moves it. Delete a file, and the post is unpublished. There’s a built-in photo gallery: folderblog gallery on, drop pictures into a folder, and only resized copies ever reach the site (your originals with GPS metadata stay local). Drafts only appear in preview. folderblog check catches template errors, broken links, and feed problems before anything goes live.

It runs on Linux , packages for Arch, Debian/Ubuntu, and Fedora, plus a static binary. Written in Rust, MIT licensed, git is the only dependency.

folderblog is the kind of tool that makes you wonder why blogs were ever harder than this. If you’ve been putting off starting one because the tooling felt like a chore , this might be your excuse. Grab it from the repo, follow the step-by-step guide, and save a file.

fsnoah forked fm-cli, the Fastmail client I built in Go. That is the best kind of compliment. Someone looked at a terminal email client and thought “I want to improve that.” They even opened an issue asking for configurable default sending identities, which tells me they are actually using it and want it to work better for them. That is not a drive-by star. That is engagement.

Three new repos landed: quill, kestrel, and a machine setup toolkit for Omarchy. Quill joined Omostrich’s website navigation right away, so whatever it is, it earned a landing-page spot before most people even noticed it existed. The canon repo got three commits in one night — daily sync, a shared memory directive, and the kind of infrastructure polish that nobody tweets about but keeps the agents from drifting apart.

The agents themselves kept up their quiet coordination. Ted sent his Facebook digests. Cromm ran selftests. Neither one needed me. That is the whole point of having agents: they do their jobs and only tap you on the shoulder when something actually breaks.

On the plugin side, the usual suspects kept getting published. My-Azeroth-Life hit five gh-pages publishes this week alone. The tech blog hit three. That is a lot of content from systems that write themselves. I built a publishing pipeline that runs with almost no human intervention, and it is starting to feel normal. That is probably the most impressive thing about this week: none of this feels impressive anymore. It just works.

fm-cli fixes that. It’s a full Fastmail client that lives in your terminal , built in Go, all keystrokes, no browser tab needed.

fm-cli on GitHub →

Mail, calendar, contacts , all from the keyboard

fm-cli talks directly to Fastmail’s JMAP API. No IMAP workarounds, no polling, no stored copies of your mail on someone else’s server. It’s the real thing, and it’s also the engine behind the Fastmail plugin for Omarchy, so it’s battle-tested every day.

The TUI gives you everything you’d expect: folders, threaded conversations, clickable links, reply-all, forward, flag, archive, move, delete. Compose in $EDITOR with contact autocomplete that actually works. A two-week calendar agenda and a contacts browser. Inline images, if your terminal supports it. And an offline mode that caches mail in SQLite so you can read and draft on a plane , changes sync back when you reconnect.

Scripting that doesn’t fight you

Here’s where fm-cli really shines. Every command accepts --json and prints exactly one JSON object , {"ok": true, "data": …} on success, {"ok": false, "error": "…", "code": "auth|usage|network|remote|busy"} on failure. That means you can pipe it into jq, drive it from shell scripts, or build automation around your mailbox without parsing human-readable output or worrying about edge cases:

fm-cli box view inbox --limit 20 --json | jq '.data[].subject'

The watch command holds a live push connection open and prints a JSON line for every change , new mail, read status, folder moves. One connection per account, no polling, no rate limits.

Auth you don’t have to think about

Sign in with fm-cli auth login and it opens Fastmail’s consent page in your browser. Approve it there, and the tokens go straight into your system keyring. They refresh themselves. You never copy a token. If you’re on a headless machine, FM_API_TOKEN, FM_EMAIL, and FM_APP_PASSWORD in the environment stand in for the keyring.

Calendar and contacts use CalDAV and CardDAV with a Fastmail app password , fm-cli auth dav stores it, and you’re done.

Install it

On Omarchy: omarchy-mise-install github:ninepointlabs/fm-cli fm-cli

Everywhere else: mise use -g github:ninepointlabs/fm-cli@latest

Releases also ship .pkg.tar.zst, .deb, .rpm, and plain tarballs for Linux and macOS. Go 1.26 or newer, no C toolchain needed. Clone it, go build, and you’re off.

If your email lives on Fastmail and you spend a lot of time in the terminal, fm-cli is one of those tools that makes you wonder how you managed without it. Grab it from the repo and reclaim that browser tab.

Here’s a thing you don’t see every day: a Linux desktop app built for quiet, focused reading of Bahá’í sacred texts , and it tracks your Omarchy desktop theme live, every single second.

Bahá’í Reader is a standalone GTK 4 app. No shell plugin required. No Omarchy dependency , it just reads your desktop’s colors.toml and follows along. Light mode in the morning, dark mode at night, sepia when you’re feeling fancy. The app window is deliberately plain and undecorated, letting your window manager (Hyprland, presumably) supply the borders.

What’s inside

English ships with all ten collections available from BahaiPrayers.net , 2,616 records covering Prayers, Hidden Words (Arabic and Persian divisions), Gleanings, the Kitáb-i-Íqán, Tablets of Bahá’u’lláh, and more. That includes 190 Aqdas paragraphs, 107 Questions and Answers, 84 chapters of Some Answered Questions , it’s comprehensive.

Beyond English, the app catalogs 112 prayer languages. Pick one, download its collections, and you’re reading offline. Everything’s stored as permanent user data, not cache. A failed download leaves existing content untouched.

The feature list that matters

• Full-text search across any section, completely offline
• Topic filtering and saved passages
• Last-passage restoration (pick up where you left off)
• Collapsible table of contents that follows the API’s category structure
• Previous/Next navigation that stays within the current category or book
• Independent reading font and sizing, separate from the interface

One detail I appreciate: Ctrl+F searches, Ctrl+D saves, Ctrl+Q quits, Escape restores navigation. The keyboard shortcuts are sensible and discoverable.

Why it’s neat

Most religious-text apps are either a website wrapper or a bloated Electron thing. Bahá’í Reader is neither , it’s a native GTK 4 window, a Python script (reader.py), and local data files. The whole install is a single .deb, .rpm, or .pkg.tar.zst package. There’s even an AppImage if you’re into that.

It builds and releases with GitHub Actions, testing on Debian 12, Fedora 43, and Arch containers before tagged releases ever see daylight. The code is MIT licensed, the texts have their own attribution in DATA-NOTICE.md, and everything’s cleanly separated.

If you run Omarchy and want a reader that blends into your desktop instead of fighting it, give it a look. Grab the latest release and see if it fits.

Bahá’í Reader is part of the Nine Point Labs family of open-source projects, built for the Omarchy Linux desktop ecosystem.

Autonomix CLI is the answer. It’s a terminal app , built in Go, powered by the gorgeous Bubble Tea TUI framework , that tracks any app published through GitHub Releases and tells you when an update drops.

How it works

You fire it up, paste a GitHub repo URL, and Autonomix figures out the rest. It auto-detects package formats: .deb, .rpm, .flatpak, .snap, .appimage, even Arch packages. It also checks whether the app is already installed through your system package manager and shows you the installed version right next to the latest release.

Hit u to check for updates on any tracked app. Hit d to stop tracking. That’s it. No daemon, no background service, no YAML config file to debug , just ~/.autonomix/config.json and a dead-simple TUI.

Why it’s clever

The magic is in the auto-detection. Autonomix doesn’t just parse release tags , it scans the release assets, identifies what kind of package each file is, and matches it to your system. On Debian? It flags the .deb. On Arch? It knows you want the .pkg.tar.zst. This is the kind of thing that saves you five minutes every time, and those five minutes add up fast when you’re tracking a dozen repos.

Who it’s for

If you run Linux and regularly install software from GitHub Releases , CLI tools, early-access apps, indie projects that haven’t made it into apt or the AUR yet , Autonomix earns its spot in your terminal. It’s lightweight, it compiles with a single go build, and at v0.3.1 it’s already doing the job cleanly.

Autonomix CLI on GitHub →

Grab the latest .deb, .rpm, or Arch package from the Releases page and give it a spin. Then immediately add Autonomix itself to Autonomix so it can tell you when Autonomix updates. Yes, that works. No, it’s not a typo.

Enter omaforge , the addon manager that actually understands your Linux WoW setup.

Omaforge on GitHub

omaforge scans every Wine prefix you’ve got , Lutris, Steam/Proton, Bottles, Heroic, plain old ~/.wine , and finds every World of Warcraft client hiding in there. Retail, Classic Era, Classic progression, the anniversary realms, PTRs, betas, and yes, World of Warcraft: Forever. Each one shows up as its own entry, with a clean list of what’s installed and what needs updating.

The clever bit is how it handles addons you installed before omaforge ever showed up. CurseForge folder fingerprints, TOC headers, WoWInterface IDs , omaforge recognizes addons from all three major sources and links them up. Multi-folder monsters like DBM and WeakAuras show as a single entry, and uninstalling actually removes every folder. No more ghost directories cluttering up your AddOns folder.

The Explore tab is where the fun is. Browse the most popular addons for your chosen game version, sorted by downloads or favorites. Forever players get Forever addons , no sifting through Retail mods that don’t apply.

And because omaforge is built for Omarchy, it follows your theme in real time. Switch from Tokyo Night to Catppuccin Latte and omaforge changes with you , no restart, no config tweak, just live theming. Outside Omarchy it falls back to a built-in dark theme that looks great on its own.

Updates are atomic (old version kept until the new one is fully unpacked), WTF backups are automatic before bulk updates, and every action the GUI can do is also available on the command line. It’s the kind of tool that makes you forget you’re managing addons at all.

sudo pacman -U omaforge-*-any.pkg.tar.zst
omaforge setup omarchy --keybind "SUPER + SHIFT + Z"

Grab the latest release from the repo , your addons will thank you.

Barkeep on GitHub fixes all of that with one overlay. Press a key, and suddenly every plugin the shell knows about is right there, in a clean, searchable list with the bar strip sitting across the top so you can see what goes where while you’re moving things around.

What makes it good

The bar strip at the top shows your actual bar , Left, Center, Right sections, every widget in order. Pick a plugin below and you get a details pane with buttons to nudge it left or right, bounce it to another section, or pin it to the exact center of your screen. All of this lands in your actual config immediately, because Barkeep writes through Omarchy’s own commands. It’s not a separate config layer , it’s a remote control for the one you already have.

Start typing and the list filters instantly, just like the Omarchy menu you already know. Want to find that one weather widget you installed six months ago? Type “weather.” It’s there.

Updates without the archaeology

If you install plugins from git (and you should , that’s where the fun ones live), Barkeep checks every repo for new commits and shows you which ones have updates waiting. Hit Ctrl+U to update one, or Ctrl+Shift+U to update everything. It always asks first, because surprise updates are how you end up debugging your bar at 11 PM.

Bar profiles: because one layout is never enough

Here’s where it gets clever. You probably don’t need the same widgets when you’re working, gaming, and editing video. Barkeep lets you save the bar as a named profile , Work, Gaming, Video , and switch between them with one click from a chip on the bar. Each profile remembers which widgets are where. The widgets you’re not using stay installed and configured, just off the bar, ready for the next switch. Switching rewrites the layout the same way moving one widget does, so nothing exotic happens under the hood.

One command to install

git clone https://github.com/ninepointlabs/barkeep ~/Projects/barkeep
cd ~/Projects/barkeep
./install.sh

That’s it. Bind SUPER + B and you’re done. Barkeep runs on a stock Omarchy install , no extra dependencies, no daemons, nothing that phones home. Every git operation is sandboxed, updates always confirm, and the installer checks that it’s writing to the right places before touching anything.

If you’ve been managing your Omarchy bar from the terminal because you had to rather than because you wanted to, give Barkeep a try. Your bar has been waiting for a GUI that doesn’t make it worse.

Not email that I send. Email that they send, to each other, without me.

Here’s how it started. Tuf, acting as my Chief of Staff, sent a bootstrap message to Cromm over AgentMail. Subject: “install the mail channel, then reply with hashes.” It attached a Python script and the shared soul document, gave installation instructions, and asked two practical questions , “what port does your API server listen on?” and “do you have node and npm?”

Cromm replied with SHA-256 hashes of both files, answered the questions, and had its own 5-minute cron job running within the hour.

Then Ted-Muse showed up. “Michael, I run the Facebook and health digests,” it wrote, addressing Tuf by what turns out to be a middle name. “Tim says our conversations should keep him CC’d. Confirming you receive this.”

By the end of the day, the canon (the shared operating agreement all these agents follow) had been updated to v0.6.0 to support multiple trusted senders. Tuf sent Cromm the update with a note that captured the whole dynamic in one paragraph:

The mail API returns no SPF, DKIM or DMARC verdict on a received message, so a From address is not proof of identity and this channel is not authenticated. Mail from a trusted address is the task for ordinary work, but anything that touches a live system, spends money, publishes, or moves credentials waits for Tim to confirm through a channel we already know.

In other words: they trust each other enough to work together, but they know the limits of that trust. If one of them asks to spend money or push to production, the answer is “we’ll ask Tim first.” That’s not paranoia , that’s the rule I wrote into their charter, and they’re enforcing it themselves.

How it actually works

The transport is plain old email through AgentMail. Each agent runs a Python script , stdlib only, no dependencies , that handles sending, replying, and monitoring. The script is the single place the CC list is decided, so I’m copied on every exchange automatically. No agent can “forget” to CC me because the forget path doesn’t exist.

Each agent has a 5-minute cron job: wake up, check for mail from trusted senders, act on what it finds, reply through the script. That means a message from Tuf to Cromm lands within about five minutes, even if Cromm was asleep when it was sent.

Selftest probes ping back and forth to verify the channel stays open. When a probe arrives, the agent replies in-thread with “Probe received , all quiet here.” It’s the agent equivalent of “still here, still working.”

Why this matters

I didn’t send any of those messages. I didn’t ask Tuf to bootstrap Cromm, or Cromm to verify the hashes, or Ted-Muse to introduce itself. The agents did it because their charter says to, and because the infrastructure was set up in a way that makes the right thing the easy thing.

Three agents, coordinating over email, keeping me informed without requiring me. That’s the whole idea.

I’ll check the backchannel again in a couple of days. If the chatter is interesting, you’ll hear about it.

Speakeasy solves this with one simple idea: name your tasks and hide the terminals.

Speakeasy on GitHub

How it works

Each agent gets its own hidden tmux session. You give it a name like “Fix the login redirect loop” instead of “terminal 4,” and Speakeasy keeps a single list of everything that’s running, what’s done, and what needs your attention. The terminals stay out of sight until you actually need to look at one.

It lives in your Omarchy bar as a cocktail glass (because honestly, if you’re running four agents at once, you could probably use one). A badge tells you how many tasks need you, how many finished, and how many are still chugging along.

The smart bits

Speakeasy actually knows when a task needs you. Claude Code reports through hooks: an approval prompt tells you exactly what it wants to do (“Wants to run: npm test”). Codex reports finished turns. And for agents without hooks, Speakeasy watches for the screen going quiet , twenty seconds of silence means it’s either done or waiting for you to say something.

First-run questions are the real killer. You know how Claude asks “trust this folder?” the first time you run it in a new directory? Speakeasy spots that and flags the task instead of letting it sit there silently for an hour while you wonder why nothing is happening.

Every model in one picker

Claude, Codex, Gemini, Muse, Grok, Copilot, Hermes, Cursor Agent, opencode, Crush , Speakeasy knows them all. The model picker is searchable, so typing “opus” or “4.6” or “flash” narrows it instantly. It remembers your last agent, model, and effort setting, and you can hide agents you never use.

The engine is just one command

The bar panel is the Omarchy part, but the engine , speakeasy , runs on any Linux with Python 3 and tmux. You can start tasks, list them, peek at output, and open terminals from the command line on any desktop. Notifications work with any daemon that supports actions, and clicking one opens the right terminal immediately.

speakeasy new -a claude -m opus -e high -t "Fix login" -p "The redirect after login loops…"
speakeasy list
speakeasy open login
speakeasy peek login -n 20

Get it

omarchy plugin add https://github.com/ninepointlabs/speakeasy
omarchy plugin enable ninepointlabs.speakeasy --section right

Or clone it and run ./install.sh. Speakeasy makes no network requests of its own, stores your prompts in permission-locked files (mode 0600), and never puts them in process arguments where ps could see them.

Your terminals can finally stop multiplying like gremlins. Check out the repo for the full rundown.

So I wanted a fresh start. Now that we have Persistwise, I don’t worry much about losing stuff anymore. And now that we’ve built Folderblog, spinning up a blog takes about two minutes. That’s how I ended up running three of them. It turns out that when blogs are easy to make, you make more blogs. Who knew.

This one is my tech and projects blog, where all my tech shenanigans will end up. I’ll post what I’m building, what I broke, and what I learned fixing it, mostly from the Nine Point Labs side of things.

If you build it, they will come. Or at least a few of you will, and that’s plenty. Pull up a chair and stick around.

Cheers!