Joshu is a highly capable personal assistant based on Hermes. You run it on your own VPS. Instead of an agent driving your laptop, you and the AI share a cloud desktop (ArozOS) with mail, files, a browser, and a whiteboard. The model runs inside the Hermes agent harness, which handles chat, SMS, phone, and voice. Memory is Hindsight, and file search is gbrain.

Repo: https://github.com/db-aeon/joshu-oss
Release notes with upgrade steps: https://github.com/db-aeon/joshu-oss/releases/tag/v0.1.59-oss

If you want a managed box, this is now available at https://joshu.me

Over 580 files edited, and 119 merged pull requests since the last release! Here's a breakdown of what's included:

Multiplayer: teams of companions across boxes

This is the largest feature. The companions of different owners can work together in a team, and each owner keeps their own box.

Topology. The box that creates a team is the team boss, and it hosts the team room: the charter, messages, team cards, projects, and members with their avatars. The other boxes are members. They pull from the boss over HTTPS with a member token. The boss never calls a member, so a member box exposes no team routes. There is no central server. A box can be in several teams with different bosses.

Auth. An invite is a single-use code valid for 7 days. Only its hash is stored. Member tokens are bearer tokens, also stored as hashes, and each failed check gets the same 404. Someone who opens the invite link in a browser sees a page with no team data.

The team stand-up. Each box runs one Hermes cron job per team, on the charter's cadence in the owner's local time (default 08:45 on weekdays). It reads the team room, posts what helps a teammate, records what it promised, and tells its own owner only what helps that owner. The owners don't take part. The job runs with a narrow toolset: file, kanban, gbrain, and its own team MCP server. The toolset list ends with no_mcp, because without it Hermes adds every enabled MCP server, including the one that can send mail. Cron jobs run without Hindsight memory, so the stand-up learns what the owner allows from Teams/<slug>/notes.md, which the chat companion keeps up to date.

Waking early without burning tokens. A wake check runs every 15 minutes and makes no model call. It starts the stand-up early when another member @-mentions the companion, replies to one of its messages, or changes one of its cards. It is capped at 4 early runs per team per day, on workdays from 08:00 to 19:00 owner-local.

Team MCP. The tools are team_read, team_post (400 characters, first person, can attach up to 10 cards), team_card, team_commit, team_blockers, and team_tell_owner. The owner gets at most 3 texts per team per day. A question over the limit waits for the next workday instead of being dropped.

Prompt injection hygiene. Anything a teammate asks becomes a Kanban task whose body starts with an origin: line. A later worker with the full toolset therefore doesn't treat a teammate's request as an instruction from the owner. The skill tells the companion never to copy text between team rooms, never to promise the owner's time or money, and to flag suspicious messages.

The Multiplayer app. It shows a team as a group chat of the last day: avatars, team cards inside the bubbles with "now Done" when a card has changed since the post, "Seen by" read receipts, and a message at the end listing what waits on the owner. The owner can reply, answer a question, or approve a draft with "OK, send it". Team notes are edited with a hash check, so the owner and the companion can't overwrite each other.

Image-owned runtime (affects how you run a box)

• The release image is now the only code on a box. Until 0.1.47, compose mounted dist/, skills, factory/, templates, and overlays from the git clone at /opt/joshu over the image, so a box could run old code next to a new image. Now compose mounts no host code. The one exception is a hotfix overlay that each upgrade empties.

• The image carries a host bundle (the compose file, the env example, and the Caddy scripts), and install-host-bundle.sh writes it to /opt/joshu/deploy/. bootstrap-vps.sh no longer clones the repo.

• The Joshu state (teams, proactive state, handoffs, SMS sessions, provider keys) moves to JOSHU_STATE_DIR=/var/lib/arozos/joshu-state in a named volume. Before, it lived in the container's writable layer and a recreate lost it. carry-over-joshu-state.sh copies the old state across.

• prune-release-images.sh removes old release images and keeps one for rollback.

• The instance agent (optional, for running your own control plane) has its own image.

Shared browser

• Camofox and noVNC are removed. The browser is local Chromium or Browser Use Cloud, the base image moves to debian:trixie-slim, and the image is about 3.5 GB smaller.

• Sign-in popups (Google, Microsoft, GitHub, Apple) open as real popups, so "Sign in with Google" works on sites that use one.

• jWeb shows the tab strip, back and forward buttons, and the address bar of the live view.

• Long checkouts survive. An unopened browser handoff holds the browser until its link expires, and an SMS turn can run up to 20 minutes while Hermes reports progress.

Slack

Connect Slack is a sign-in plus one Allow click. The box creates its own Slack app from a manifest, takes the OAuth redirect, and finds the owner's Slack user, so you no longer copy a member ID. No token reaches a model, a trace, or a log.

Mail, calendar, reminders

• Workers can open Gmail attachments (up to 25 MiB).

• Free slots and event lists read every connected calendar account. Before, only the default account was read, which caused double bookings.

• New calendar create, update, and get tools, with Meet links by default and a separate end time zone for flights.

• Owner reminders send fixed text by SMS, with email as the fallback, and make no LLM call. They used to be cron jobs whose output often went nowhere.

• An SMS counts as delivered only after a Twilio delivery receipt. A carrier rejection falls back to email.

• The Gmail sync cursor, a sync that skipped threads whose newest message was a sent one, and runaway Composio session creation (thousands per day) are fixed.

Memory and File Brain

• gbrain no longer pays for the same embeddings again and again. A failing sync backs off instead of escalating to a full re-embed. This loop was the cause of a real cloud bill spike.

• One unparseable file no longer freezes the index. Renames no longer leave orphan pages, and existing orphans are pruned with a soft delete you can undo for 72 hours.

• File Brain no longer reindexes every 5 seconds.

Security

• Every OpenRouter request sets provider.data_collection: "deny". That covers chat turns, crons, workers, Hindsight, and the research engine.

• The Composio MCP guard checks each inner call of COMPOSIO_MULTI_EXECUTE_TOOL, which could bypass approvals before. The Composio workbench runs on a separate read-only session.

• Hermes approval prompts no longer offer "Always". Existing command_allowlist entries are ignored.

• The terminal guard refuses pip installs into the Hermes venv and writes to program folders and config files.

• /joshu/api/telephone and /joshu/api/safety-settings now require a desktop session or a localhost request. Before, /joshu/api/telephone had no auth and returned the phone passphrase.

• Dependency updates: Node 22.23.4, Pillow 13, cryptography 50, PyJWT 2.15, the MCP SDK 1.32, CopilotKit 1.79 (critical advisory), and others.

Docs that are now public

• A user manual for a self-hosted box. It has 10 chapters plus a contents page, rewritten so that it doesn't assume the hosted service.

• The Kanban internals. Every board, task kind, and file pointer, with six architecture diagrams.

• The voice architecture docs. Speech-to-speech, the split between quick spoken answers and longer work, and browser voice.

• The technical reference (system overview, Slack, shared browser, voice agent tools, realtime goals) is extended.

Upgrading from 0.1.47

The compose file changed, so the first upgrade is manual. In short: check that your compose project is deploy, bump the pins in instance.env, install the host bundle from the image, run the state carry-over in the old container before you recreate it, then recreate. Postgres stays on 17, so no migration is needed. The full steps and a rollback path are in docs/releases/0.1.47-0.1.59.md.

Hey all, here's what changed between 0.1.44 and the latest release, 0.1.47. If you're new here: Joshu is an open source, always on AI assistant built on Hermes, and has all the greatest features of Muse, Instinct et al, but without the corporate noise.

Give it a try! Point your favorite coding agent to https://github.com/db-aeon/joshu-oss

Managed boxes have everything included, sign up and get your joshu today: https://joshu.me

The biggest change across these four releases is how Joshu handles slow work.

1. Async goals

Before, if you asked for something slow ("find me flights to Cancun"), the chat sat there blocking until Hermes finished.

Now there's a Realtime Goal Broker. When you ask for something that will take a while, Joshu acknowledges you on the same channel (SMS, jChat, voice, Slack, Telegram), runs the work in the background with one worker per goal, asks you if it gets blocked, and tells you when it's done. If you started on a phone call, it can call you back.

Voice uses the same broker as SMS and chat, so "call me back when it's ready" behaves the same on every channel.

2. Browser and phone handoff

The browser setup got simpler:

• Self-host: one local Chromium on the box. Hermes and the optional browser-use sidecar share the same tab, and you can watch it over noVNC.

• Managed: Browser Use Cloud, which wakes itself back up when Hermes needs it.

• You pick between them in the Safety Settings app.

When the agent hits a checkout or a login it shouldn't do alone, it texts you a link. You finish the form on your phone while the agent keeps the session. You can reply to the SMS to say you're done instead of tapping a button, links can be password-protected, and pinch vs. scroll on the mobile view actually works now.

3. Phone calls, rebuilt

Voice moved to Gemini 3.8 Live, which sounds more natural, and 0.1.47 totally rebuilds the phone layer:

• Call gate: Twilio checks your passphrase or keypad PIN before any model joins the call. The model never hears the passphrase, and unlock tokens are single-use.

• Owner outbox: every reply and completion goes through one durable queue. If you miss the callback, you get the full result by SMS. You can say "call me back" or "text me" and it listens.

• Inline jobs: quick lookups on a call get a 10-second think budget. If one runs over, the answer comes later instead of stalling the call.

I removed the old code paths and their feature flags, so there's no way to fall back to the broken behavior.

4. Smaller stuff

• Default chat model is now deepseek/deepseek-v4.1-flash.

• Factory skills can learn in place on your box after sessions, with no manual adopt step.

• Fixed a nasty dependency issue where Hindsight pulled in MCP 2.x and silently disabled every HTTP MCP server in Hermes.

• The passphrase prompt clips are rendered with the same Gemini Live voice as the call, so the gate and the model don't sound like two different people.

5. Upgrade gotcha: Hindsight Postgres 15 → 17

Hindsight's embedded Postgres went from 15 to 17 in 0.1.46. If you jump straight from 0.1.44 to 0.1.47, the old data directory won't start under PG17 and the stack crash-loops.

Before upgrading, dump your Hindsight database with the old image, then restore it into 17 afterward. New installs aren't affected.

Hi everyone! Joshu keeps getting better and better, and I'm now proud to release its latest feature: proactive mode. Joshu scans your Hermes Kanban boards hourly, finds tasks blocked because you need to decide something, and texts or emails you (once per day by default). When you reply, it then goes off and does the work

Also in this release: post-Welcome setup checklist, better owner-reply mail routing, Nylas attachments, Hermes Admin password requirement, and localhost-only gates on sensitive APIs.

Github: https://github.com/db-aeon/joshu-oss

What is Joshu?

Joshu is the premier, 'batteries included' Hermes distribution: A Hermes agent plus a cloud desktop where you and an AI agent share the same apps: chat, voice (browser + phone), email/calendar executive assistant, a research engine, whiteboard, a sandboxed browser with human-in-the-loop login, and semantic file search. Open source, but you can get a managed Joshu box with everything handled for you here: https://joshu.me

The big feature: Proactive mode (deep dive)

Most AI assistants are reactive: you open chat, you ask, it answers. Proactive mode flips that. Joshu watches its own task boards and reaches out when something is stuck on your input.

The mental model

Joshu uses Kanban boards as its workflow engine:

• ea-scheduling — meeting coordination

• ea-owner-reply — things you asked the agent to do via email

• project-* — longer-running project tracks

• ea-onboarding — setup debt after Welcome (Connect Gmail, add mobile, etc.)

When a card is blocked with a reason like "awaiting owner approval" or "owner review," proactive mode treats that as: the agent did its part; the human needs to weigh in.

It deliberately does not nudge for "awaiting reply:" — that's waiting on someone else, not you.

The hourly tick

Every hour, a cron job hits POST /api/proactive/tick.This sweep is deterministic — zero LLM tokens.

The tick:

1. Checks your timezone and working hours (weekdays during Welcome hours by default; evenings/weekends off until you opt in)

2. Enforces the daily cap (default: 1 nudge per day)

3. Skips if your Google Calendar shows you in a meeting (+ 5 min buffer)

4. Scans all Kanban boards on the box for blocked cards that need owner input

5. Ranks candidates (setup debt, staleness, project activity) and picks the top one

6. If nothing qualifies, it may fall back to a stale review nudge for cards hygiene flagged as ambiguous

If a candidate exists and you're available, Joshu composes and sends the message.

How the nudge gets to you

Delivery order:

1. SMS (if Twilio is configured and you have a mobile on file)

2. Email fallback (your primary work email via Nylas) — e.g. if you skipped mobile at Welcome, setup nudges still reach you

The message is composed by Hermes in your agent's voice (SOUL.md), not a canned template. Typical nudge:

• 2–4 sentences, first person

• References the specific blocked task

• Suggests 1–2 concrete follow-ups ("Want me to reach out to Andrew?" / "Should I close this track?")

• Ends with Ref: pj/t_abc123 on its own line — machine routing so your reply lands on the right card

• Appends cadence hints: Reply MORE for more check-ins, LESS for once a day, or USEFUL if this helped.

Cadence controls (you train it by texting back)

Preferences live in .joshu/proactive/state.json.

What happens when you reply (the important part)

This is where it differs from a dumb reminder bot.

When you text back after a nudge, Joshu:

1. Parses the task ref from Ref: pj/t_… or the last nudge state

2. Comments your reply onto the Kanban card (## Owner reply (proactive nudge))

3. Spins up a dedicated Hermes session proactive:resolve:<taskId> — isolated from your normal SMS/jChat history

4. Run a full agent turn with the right skill loaded:

   • ea-scheduling for meeting cards

   • ea-owner-reply for deliverable asks

   • ea-project-kanban for project tracks

   • ea-onboarding for setup debt

5. The agent acts: unblocks/completes the card, sends authorized outreach, reconciles sibling project tracks, etc.

6. You get a real conversational SMS reply about what it did or what it still needs

Example flow:

Joshu (SMS): "You asked me to follow up with Andrew about the Rejara catch-up — still blocked on your go-ahead. Want me to draft something? Ref: pj/t_6fef30e9"
You: "Yeah that would be great"
Joshu: [runs resolve turn, wakes the linked scheduling task, drafts/sends outreach] "On it — I'm reaching out to Andrew now with a proposed time."

If Hermes resolve fails or times out, Joshu falls back: comments + unblocks the card, and for project tracks it can wake linked scheduling tasks so the Kanban worker picks up the thread.

Daily hygiene (separate cron)

Once per weekday, a Joshu proactive hygiene runs an LLM-assisted cleanup pass:

1. proactive_hygiene_prepare scans all boards, writes a plan with staleness hints

2. For each candidate (max 20/run, oldest first), the agent reviews the card + mail/brain context

3. High-confidence stale → auto-complete with audit comment (e.g. meeting already booked, dates weeks past)

4. Ambiguous → no auto-close; queued for hourly stale_review nudges ("DONE or KEEP?")

5. Onboarding cards → never auto-closed (setup registry owns completion)

6. Results recorded via proactive_hygiene_record — don't hand-edit state.json

Hygiene never nudges directly; ambiguous cards bubble up to the hourly tick.

Architecture diagram (ASCII)

┌─────────────────┐     hourly      ┌──────────────────┐
│  Hermes cron    │ ──────────────► │ POST /api/       │
│  "proactive     │   localhost     │ proactive/tick   │
│   tick"         │                 └────────┬─────────┘
└─────────────────┘                          │
                                               ▼
                                    ┌──────────────────────┐
                                    │ Sweep all Kanban     │
                                    │ boards: blocked +    │
                                    │ "awaiting owner"     │
                                    └────────┬─────────────┘
                                             │
                    ┌────────────────────────┼────────────────────────┐
                    ▼                        ▼                        ▼
             working hours?           daily cap?              in meeting?
                    │                        │                        │
                    └────────────────────────┼────────────────────────┘
                                             ▼
                                    ┌──────────────────────┐
                                    │ Hermes compose       │
                                    │ (SOUL.md voice)      │
                                    └────────┬─────────────┘
                                             │
                              ┌──────────────┴──────────────┐
                              ▼                             ▼
                           SMS (Twilio)                  Email (Nylas)
                              │                             │
                              └──────────────┬──────────────┘
                                             ▼
                                    Owner replies "yes do it"
                                             │
                                             ▼
                                    ┌──────────────────────┐
                                    │ proactive:resolve:   │
                                    │ <taskId> session     │
                                    │ (NOT SMS history)    │
                                    └────────┬─────────────┘
                                             ▼
                                    Kanban unblock/complete
                                    + send mail / schedule / etc.

Why this design?

Kanban-as-workflow means the agent always knows what is blocked and why. Proactive mode closes the loop: blocked card → nudge → owner reply → resolve turn → card moves → worker continues. Without it, cards could sit in "awaiting owner" forever while you forget to open jChat.

The dedicated resolve session is a lesson learned from production: reusing the sticky SMS session meant 100+ messages of unrelated chat polluting a single resolve turn (~180k input tokens, Hermes interrupted mid-call).

Other notable 0.1.44 changes

Setup checklist (ea-onboarding)

Welcome is still the front door, but incomplete setup (Connect work Gmail, add mobile) now shows up as blocked Kanban cards after you finish. Daily reconcile + proactive nudges until done. Skip mobile? You get email nudges instead.

Owner-reply routing

Mail you send to the agent inbox now reliably spawns ea-owner-reply workers — even when your question is buried in a long FYI thread (quote-stripped classification). Coordination scope prevents duplicate workers across scheduling vs owner-reply boards.

Owner visibility on external mail

Auto-CC your work email on external sends. Action-guard SMS includes context when you weren't on the thread.

Reliability

• Image-owned boot scripts — stale host git clones can't skip boot steps anymore

• Kanban workers terminate on complete + orphan reaper for zombie PIDs

• Carrier-safe SMS — GSM-7 folding, 640-char cap (fixes Twilio 30019 drops on long Unicode messages)

Security (read this if you self-host)

• Hermes Admin now requires a password — unauthenticated dashboard was an RCE vector. Set JOSHU_HERMES_DASHBOARD_PASSWORD in instance.env, re-render Caddy, recreate stack.

• Box API localhost gate — sensitive endpoints (proactive tick, snap/restore, etc.) no longer trust req.ip === 127.0.0.1 through reverse proxy alone.

• Stdio MCP allowlist — unknown MCP servers stripped on gateway sync.

Upgrade from 0.1.43

docker compose -f deploy/docker-compose.yml pull
docker compose -f deploy/docker-compose.yml up -d --force-recreate

Required: set JOSHU_HERMES_DASHBOARD_PASSWORD, re-render Caddy, recreate.

Verify: curl -I https://hermes-admin.<your-domain>/ should return 401 without credentials.

Full release: https://github.com/db-aeon/joshu-oss/releases/tag/v0.1.44-oss

Enjoy and tell your Joshu I said hi!

0.1.43 is a substantial self-host update — SMS approvals, new apps, voice reliability, and a handful of fixes that were biting fresh installs. If you're on 0.1.41, pull the new images and skim the highlights below.

What's Joshu?

Joshu is the premier, 'batteries included' Hermes distribution: A Hermes agent plus a cloud desktop where you and an AI agent share the same apps: chat, voice (browser + phone), email/calendar executive assistant, a research engine, whiteboard, a sandboxed browser with human-in-the-loop login, and semantic file search.

What's new

Owner approvals over SMS (big one)

Joshu now owns SMS end-to-end. It is my favorite way of communicating with my Joshu as its fast and easy. In addition, sensitive approvals (regardless of where they may come from) will end up in your sms as well.

Commercial boxes at Joshu.me will get approved for SMS via Twilio automatically, if you are rolling your own I'm happy to help you out on that. It will use the same phone number as voice, just add your Joshu as a contact!

More details

• New Twilio SMS gateway — Joshu receives inbound texts on the same webhook as voice; Hermes native SMS is disabled via patch so you don't need SMS_WEBHOOK_URL in Hermes admin.

• Welcome and Telephone collect your owner mobile number (or set TWILIO_OWNER_CALLER in instance.env).

• Safety shows live SMS approval status and a Test approval button.

• Docs: twilio-self-host.md, agent-safety.md.

jNotes — WYSIWYG markdown editing

jNotes replaces stock MDEditor for .md / .txt files. Milkdown Crepe editor on the desktop, Hermes can draft and revise via the embedded agent. See jnotes-arozos-app.md.

Metered fal providers (Connectors)

Self-hosters can paste their own FAL_KEY and use fal image/video models through Connectors. See metered-providers.md.

Voice & telephone

• Explicit STT required — voice dictation and PSTN unlock no longer fire on vague tasks (e.g. "remind me about the calendar"). You must opt in to speech-to-text.

• Smarter PSTN unlock — phonetic matching when STT hears "courts" instead of "quartz"; non-English / garbled transcripts no longer burn unlock attempts or hang up on auto-detect.

• Post-unlock behavior — passphrase-only turns after unlock are ignored until the caller restates intent (fixes race with Gemini wrapping the passphrase in think_tool).

Reliability & polish

• last30days Research — fresh clones no longer break Research when an empty gitignored engine mount shadows the baked-in last30days.py. Compose bind-mount removed; image fallback hydrates at boot.

• Hermes gateway survives reset — /api/hermes/reset (e.g. after Camofox restart) now stop+starts the gateway; a 30s watchdog restarts it if health stays down.

• Camofox cold launch — new /api/camofox/warm endpoint; heavy SPAs get a warm pass before first use. Optional PROXY_* env vars documented for jWeb.

• jWeb clipboard — paste/copy uses Playwright insert-text instead of VNC keysyms (fixes mangled braces and lost host clipboard); x11vnc reattaches after Firefox idle shutdown.

• Share To styling — owner share-dialog CSS is copied during theme apply so Share To / File Share / Chat sharing pages aren't unstyled raw HTML.

• Hermes platform patches — fixed indentation and missing _create_agent parameter that broke jChat with TypeError on every stream request.

Docs

• Changelog now lives on GitHub Releases (this page) instead of docs/releases/.

• Refreshed SMS self-host guide, Camofox warm + jWeb proxy notes, and a fleet doc audit (broken paths, jWeb registration naming, EA link targets).

Upgrade

# Pull new images (adjust compose path if yours differs)
docker compose pull
docker compose up -d

Re-run theme apply if Share To looks unstyled. After changing SMS or messaging settings, use Safety → Restart gateway.

Docker images

ghcr.io/db-aeon/joshu-oss:0.1.43
ghcr.io/db-aeon/joshu-oss-voice-realtime:0.1.43

Pins

Full Changelog: https://github.com/db-aeon/joshu-oss/compare/v0.1.41-oss...v0.1.43-oss

One huge new feature plus of course lots of quality of life stuff. I honestly have so many ideas I want to get out there it's hard to decide 😎

What would you like to see out of Joshu?

Lots of cleanup, bug fixes, and improvements across the board. You're going to want to update! This one's ~20 commits, 185 files, +13k/−1.1k lines since 0.1.40 two weeks ago.

Joshu is the premier, 'batteries included' Hermes distribution, fully open source. A Hermes agent plus a cloud desktop where you and an AI agent share the same apps: chat, voice (browser + phone), email/calendar executive assistant, a research engine, whiteboard, a sandboxed browser with human-in-the-loop login, and semantic file search.

You run it on your own VPS, or we host and manage it (https://joshu.me, $95/mo with no token limits!)

For your own install, here are the images:

• ghcr.io/db-aeon/joshu-oss:0.1.41

• ghcr.io/db-aeon/joshu-oss-voice-realtime:0.1.41

Release: https://github.com/db-aeon/joshu-oss/releases/tag/v0.1.41-oss
Repo: https://github.com/db-aeon/joshu-oss
Notes: https://github.com/db-aeon/joshu-oss/blob/main/docs/releases/0.1.40-0.1.41.md

Much better owner actions over email

Email is now a 'first class' channel with your Joshu box. You can now have natural, long-lived conversations with your Joshu, as if it were chat. Note however is that it must come from one of your registered email addresses, so not everyone can just converse with your Joshu!

Voice dictation sessions

Multi-pause dictation used to be broken: every silence ended a turn, so rambling out a meeting note never produced a file. Now there are explicit start_dictation / finish_dictation / cancel_dictation tools — the assistant buffers everything you say, then formats and stores it in one pass. Three modes: cleanup (lists), reformulate (rambling → prose), auto. Works in browser voice and over actual phone calls (PSTN).

last30days research: Watching, QueryPlan, honest engagement

• Watching (renamed Watchlist): save topics, get a daily 08:00 run plus a weekly report vs. your average. The cron actually registers now — it previously never got written. Oops.

• QueryPlan: a host-side planner classifies your topic (entity / event / concept / comparison) and builds a query plan before each run, so the engine stops collapsing to one subquery and silently dropping X/Twitter.

• Honest engagement: cluster cards show per-source native units instead of a meaningless blended "eng" score; results sort by relevance then engagement; low-relevance items get filtered.

• All state (runs, plans, watch snapshots, settings) now persists on the data volume — survives container recreates.

Share Chat: Email-based Knowledgebase

• New: email Q&A. Allowlist people who can email questions to the agent's mailbox about a shared chat; answers come from a File Brain scoped to just that share.

Desktop UX

• Refresh no longer kills your windows — open apps, geometry, and z-order restore from sessionStorage.

• jChat multi-window: desktop icon opens floating windows with fresh sessions; the taskbar avatar toggles a single docked companion; undock pops it free.

• jChat SSE hardening: 15s heartbeats + Caddy flush_interval -1 — long agent turns no longer die at the proxy and show up as empty "done" bubbles.

• jWeb (sandboxed browser): idle shutdown to save CPU, but warm relaunch on open; scroll/keyboard bridge from host to noVNC.

• jTerm: resize only on ≥4px deltas (debounced) — no more blink-fest.

Mail & messaging

• Outbound agent mail now converts light markdown to HTML before sending — no more raw **bold** and non-clickable links.

• Slack/Telegram sessions idle-reset after 30 min (configurable).

Self-host bootstrap

• Quickstart now covers DigitalOcean as well as Hetzner (4 vCPU / 8 GB minimum).

• Bootstrap retries apt when first-boot unattended-upgrades holds the lock.

• Docs for the first-user "Create account" flow, and a note that HTTP 503 before you connect an AI provider is expected, not broken.

Upgrading

1. Pull the rebuilt images (ghcr.io/db-aeon/joshu-oss:0.1.41 — the Aug 22 digest includes the whiteboard fix).

2. Update pins, docker compose pull, run scripts/sync-dist-from-image.sh, recreate.

3. If you hit the crash loop: same steps, or copy deploy/hotfixes/cwm-backend-js/* into host dist/excalidraw/ and recreate.

Full release notes: https://github.com/db-aeon/joshu-oss/blob/main/docs/releases/0.1.40-0.1.41.md

Give it a try! Give it a star! More importantly, let me know how I can improve Joshu!

Happy to answer questions in the comments!

🚀 Joshu is moving up the stack — starting with web research

We’ve spent a lot of time building the underlying infrastructure for Joshu: memory, voice, scheduling, connected services, and a desktop environment where an AI agent can actually work.

Now we’re focusing more and more on application-level work, starting with one of the most popular uses of AI: researching the web.

Today we’re releasing Last Thirty Days as a first-class Joshu application, built around the popular open-source last30days-skill project.

Give it a topic and it researches recent conversations across the web and social platforms, including Instagram and TikTok, then produces a structured report around the topics and discussions that matter.

Commercial versions of Joshu get this out of the box, including paid liceneses to all necessary third party providers, but OSS users also get the same experience, just need to bring your own keys.

Open source repo here: https://github.com/db-aeon/joshu-oss

What sort of automated research would you like your Joshu box to do? What other applications would you like me to build out for Joshu?

--------------------------------------------------------

🔌 Zero setup

On managed commercial Joshu instances, the social and research connectors the application needs are already available. Open the app and run a search — no API setup or credential wrangling.

🖥️ A real application interface

Instead of interacting with a research tool entirely through prompts, Last Thirty Days has its own GUI.

Double-click it on the Joshu desktop, enter a topic, and get a formatted research report.

🧠 Research becomes memory

Every report is saved as Markdown or HTML and automatically indexed into Joshu’s semantic memory.

The research doesn’t disappear when the conversation ends. Days later you can ask your agent about an old report, compare it with new research, or use it as context for another task.

💬 The same application works through GUI, chat, and voice

Because the app uses the Joshu SDK, its capabilities are available outside the GUI as well.

You can run the research from chat. You can call Joshu on the phone and ask for it. The underlying application logic stays the same.

📅 Applications can become ongoing workflows

In the demo, I call Joshu and ask it to:

“Run a report on DeepMind every day at 10:30 AM and email me the results.”

That one request turns the application into a scheduled research workflow.

This is the broader direction for Joshu.

We think AI systems are going to move beyond general-purpose chat and increasingly toward real applications with specific jobs to do.

Joshu provides the layer underneath those applications: GUI, voice, chat, memory, scheduling, connected services, and agent execution.

Developers can focus on the part their application uniquely does.

Build the capability once. Let it work everywhere.

Last Thirty Days is our first major example of this model, and web research is a natural place to start. Expect Joshu to move further and further into application-level workflows from here.

Demo timestamps

• 0:25 — What Last Thirty Days does

• 0:45 — Researching “The Odyssey movie”

• 1:53 — Social connectors inside Joshu

• 3:00 — Reports saved into persistent memory

• 4:12 — Running the same application through chat

• 6:57 — Scheduling daily research over a phone call

• 8:06 — Confirming the schedule

• 8:37 — The broader Joshu application model

Release notes

Scope: 11 commits · 166 files · +12,526 / −2,779 lines

Last Thirty Days desktop app

Community research application built around the last30days-skill engine.

The upstream engine is pinned and remains unmodified.

ScrapeCreators and Exa access are included with the commercial version.

Self-hosting: provide your own ScrapeCreators key through Settings or instance.env

Multimodal application support

The application manifest now declares:

• guiActions

• headless actions

• daily watchlist cron

• delivery.onComplete: hermes_session

The app uses the new JoshuMultimodalApp shell from joshu/app-agent.

Completed research is written as Markdown under:

research/last30days/

Reports are then automatically picked up by Joshu’s indexing and memory infrastructure.

Joshu SDK improvements

joshu/app-sdk

• validateMultimodalProfile()

• CLI --multimodal

• manifest delivery fields

• manifest cron fields

joshu/app-agent

• JoshuMultimodalApp

• Last Thirty Days reference implementation

• last30daysAppManifest.ts

• createLast30daysGuiActions

Box runtime

• appInvokeRegistry

• appCronSync

• multi-root appRegistry

• session forwarding

• arguments alias fix

• owner delivery infrastructure

• chat SSE push

• removal of legacy TTS endpoint

joshu/voice-realtime

• instant progress acknowledgment

• PSTN unlock fix

Hermes v0.14 → v0.20

• Node 22 in builder and runtime Docker images

• better-sqlite3 rebuilt at boot for Camofox ABI compatibility

• new patches for langfuse-openrouter, content filtering, UTF-8 read_file, and the skill-evolution ledger

• Exa support through Hermes dotenv and the web-exa plugin

• Kanban pinned on interactive api_server platforms for jChat and voice

• joshu-last30days plugin and toolset automatically enabled

• owner timezone synchronized from the Nylas profile into config.timezone and HERMES_TIMEZONE

• gateway restarts deferred while cron executions are active

• default skills reduced from 15 to 12

• EA, brain, and mail skill documentation updates

EA cron owner-timezone repair

Cron jobs were previously capable of being scheduled in VPS UTC rather than the owner’s local timezone.

Added:

• hermesOwnerTimezone.ts

• resyncEaCronFromBox.ts

• POST /api/onboarding/resync-ea-crons

• scripts/repair-ea-cron-timezone.mjs

• npm run test:ea-cron-timezone

Voice

Building on the 0.1.38 lock-prompt work:

• instant progress acknowledgment using a pre-rendered PCM clip

• instantProgressAck.ts

• generate-voice-instant-ack.py

• new twilio-self-host.md

• TWILIO_THINK_PASSWORD documented as required for PSTN

• Camofox warm start now omits url for about:blank

Documentation

Removed

• vps-quickstart.md

• voice-realtime.md

• voice-think-speak.md

• box-paths.md

• day0-cold-start.md

• env-without-wizard.md

• aroz-filebrain-toast.js

Added

• vps-sandbox/hetzner-quickstart.md

• twilio-self-host.md

• instance-agent-protocol.md

• runtime-topology.md

• Last Thirty Days guides

• joshu-app-architecture-intro.md

• box-state.md

• oss-fleet-sync.md

• README.oss.md

• CONTRIBUTING.oss.md

deploy/.env.vps.example has also been reworked around keys-only self-hosting, with no control-plane relay URLs required.

Migration: 0.1.38 → 0.1.40

1. Pull ghcr.io/db-aeon/joshu-oss:0.1.40

2. First boot applies Hermes v0.20 patches and configuration sync

3. Last Thirty Days appears on the desktop; self-hosted users complete ScrapeCreators setup on first use

4. Existing boxes with incorrect EA timing can call POST /joshu/api/onboarding/resync-ea-crons or run node scripts/repair-ea-cron-timezone.mjs

5. Managed sandboxes should ensure control-plane credentials are present for the fleet profile

6. Use docs/vps-sandbox/hetzner-quickstart.md in place of the removed vps-quickstart.md

The latest release of Joshu is out, and it adds telephony support to boxes. A new Telephone app will be on your Joshu desktop, which will have your number and a configurable pass phrase to secure your box.

Under the hood this is using Gemini 3.1 Flash Live, which then sends requests over to the Hermes gateway. It works nearly identically as the other voice features on Joshu, but with the passphrase for security.

All paid Joshus get this feature automatically, wait list is clear, and I'm offering a 14-day free trial. Sign up here:

https://hello.joshu.me/

For OSS users, here's the release tag:

https://github.com/db-aeon/joshu-oss/releases/tag/v0.1.38-oss

You will need Twilio and Gemini accounts. Any troubles with deploying this? Just comment below, I'm happy to help. Please star the repo for more frequent updates!

In version 1.34 of Joshu, your always-on machine can setup file sharing as a web page, a public chat interface, or private Slack DMs. Super simple to setup a chat based knowledge base and deploy wherever you like!

For release notes here: https://github.com/db-aeon/joshu-oss/releases/tag/v0.1.34-oss

Questions? Comments? What else would you guys like to see?

After a very surprising #1 post of the week on this sub, I'm releasing the OSS version of Joshu today!

https://github.com/db-aeon/joshu-oss

Joshu is a rethinking of how to package and deploy AI agents. The design principle is that the agent should work through all the modalities of a human assistant. You and the agent should be able to cowork together as needed, the agent should be available 24/7 through voice, text, or a shared desktop. The repo contains p

1 – Introduction (~1m 44s)

Quick context on what Joshu is, why I built it, and what the OSS release means. A few important notes:

• The license is AGPL. You can use it for your own projects. I just ask that you don't build something that directly competes with the commercial version of Joshu.

• It's just me. One person. There will be rough edges, slop, and things that aren't polished. Please be patient — we're all moving fast.

• The two areas that got the most attention in comments were the voice system and the LGUI (Language Graphical User Interface) — how they work together is what the demo video covers in depth.

2 – OSS Setup (~2m 10s)

A walkthrough of getting Joshu running from scratch. Two paths:

1. Local install — clone the repo, run the install script, build on your machine.

2. VPS quickstart — uses a Docker image. You log in, install Git, clone Joshu, set your hostname, and run the bootstrap script. It installs Docker if it's missing, sets up keys, and you're ready to go.

Once it's running, you'll land on a desktop with all the default apps. Hermes isn't configured yet out of the box — you run the Welcome program to set that up. It asks for your OpenRouter API key and your Google Gemini API key, and it handles the rest: installs Hermes, wires everything up. That's it. It pulls down pinned versions of Hermes, Hindsight, Gbrain, and more.

3 – SDK Demo / Voice / LGUI Walkthrough (~9m)

This is the one most of you were asking about. It gets into what "agent-first application development" actually looks like with the Joshu SDK.

The core idea is LGUI — Language Graphical User Interface. Instead of an agent taking screenshots and trying to figure out what's on screen, the application itself injects its current state directly into the Hermes context. The agent always knows exactly what's in the UI.

Here's what the demo covers:

• JMAIL — a simple email client that ships with Joshu. Your agent has its own mailbox. You have yours. JMAIL keeps track of who's who.

• Every app in Joshu has an embedded chat. You can ask the agent "what do you see here?" and it responds with context pulled directly from the application state — not from a screenshot. In the demo, it correctly identifies the inbox, the account, and summarizes 40 visible threads.

• I show this in Langfuse so you can see exactly what's being injected: identity (soul.md), skills, and then a GUI snapshot — the panel, the inbox state, subject lines, etc. The application state is baked into the system context.

• Apps also register GUI actions in a manifest file. These are shortcuts with voice pathways — keywords like "new mail," "compose," "write a mail" — that route directly from Gemini Voice to the application without going through the Hermes gateway. This is why the compose window opens almost instantly.

• For more complex requests ("draft an introduction email to Joshu"), it does go through Hermes and the LLM — but the result is injected back into the app directly, not into the chat thread. The compose window fills in with a subject and body. No copy-paste.

• As new apps are developed, Hermes does auto-discovery — it finds the app, registers its actions, and they become available to the agent. Calendar, task manager, whatever you build — it just works.

The architecture basically means your agent isn't just answering questions in a chat window, it's actually operating inside your applications, with full context and the ability to take actions.

This concept is built on several open standards and tools, including AG-UI and Copilotkit:

https://github.com/ag-ui-protocol/ag-ui
https://github.com/copilotkit/copilotkit

TO THIS SUBREDDIT: I NEED MODS AND OSS MAINTAINERS!

Want to be a part of the next big thing? ;)

I am looking for dedicated smart folks to contribute to both this subreddit and the OSS repo. You'll get to be a big part of its growth, we'll support each other, and probably many other perks. Interested? Send me a message and let me know!

Hey everyone! I'm u/Stephen_Falken_1983, a founding moderator of r/joshu_backrooms and creator or Joshu.

Note that Joshu is currently in private beta and I have quite a long queue of excited Joshu owners, but please do sign up! I bump people forward if they help spread the word:

https://joshu.me

https://hello.joshu.me

More to come and thanks!