Hands that do things. On their own. On your terms.

What is Ashe?

Ashe is Nimbus8's on-device agent runtime. It runs small, scheduled workflows called Hands — each Hand is a tick schedule, a set of allowed tools, and a model that glues them together. When a Hand fires, Ashe drives it step by step and writes every step to a live activity feed.

There is no cloud agent loop, no hosted tool server, no remote model inference. Tools run in-process in the iOS sandbox. Models run on your device. The feed, the logs, and the confirmations all live on disk.

How do Hands work?

A Hand is the atomic unit of automation in Ashe. It's defined by three things:

• A tick — a schedule, expressed in plain intervals (every 15m, every hour, every morning at 8).
• A skill set — the specific tools this Hand is allowed to call. Nothing outside this set is reachable.
• A model — the on-device LLM that drives the loop, typically a tool-use-capable 3B or 7B.

Hands are enabled one at a time. There is no "auto-discover and wire up" mode; you opt each one in, you see what it does, and you disable it with a single tap. Every run produces an entry in the activity feed whether it succeeded, was blocked by confirm-first, or errored out.

The confirm-first policy

Ashe classifies every tool call as read-only or side-effecting. Read-only calls (list inbox, read a file, parse a calendar) run freely inside a Hand's tick. Side-effecting calls — anything that writes, sends, deletes, or touches the network — pause the Hand and surface a confirmation card with the exact action, the exact target, and the exact payload.

The Hand does not resume until you tap to approve. If you never look at the feed, nothing happens. This is intentional: Ashe is a planner and a drafter, not a spender of your trust. The trade-off is fewer "magic" moments and more short, legible ones.

Tools & skills

Skills are small, typed capabilities the runtime exposes to a Hand. The first-party set covers the integrations most automations actually need:

• Apple Calendar — read events across every account already on the device. Writes are confirm-first.
• Apple Reminders — read and create reminders across your lists. Writes are confirm-first.
• Email — Gmail (App Password) and any IMAP/SMTP host. Reads stream subjects, senders, and a body preview; sends are confirm-first.
• Files — security-scoped picks from iCloud Drive, Dropbox, Google Drive, OneDrive, or any provider in the Files app. No vendor token required.
• Obsidian — pick a vault folder once; Ashe can read selected notes by id without ever holding network credentials.
• RSS / Atom feeds — paste a feed URL. Anonymous fetch, no logins.
• Web search — Brave, Tavily, Kagi, or SearXNG via your own API key. Searches are confirm-first the first time.

Each skill is a Swift module shipped with Nimbus8. There is no dynamic code loading and no remote plugin registry — if a skill isn't in the app binary, a Hand cannot call it.

Connect tools

Ashe ships with every tool wired up but no credentials. The first time a Hand or a prompt needs an account, Ashe pops the matching connector sheet on top of the run — Gmail's App Password screen for email, the system permission prompt for Calendar or Reminders, the document picker for Files. Finish setup and re-run the same prompt; Ashe picks up where it stopped.

The full connector list lives on the Ashe tab itself: open Ashe before any run, and the empty Activity surface lists every connector with a Connect button. The same list is reachable from the "?" guide in the top-right and from Settings → Connectors.

Credentials are stored only in the iOS Keychain on this device. They are never synced to iCloud, never sent to a Nimbus8 server, and never shared between apps. Disconnecting a tool wipes the Keychain entry immediately.

The activity feed

The feed is the ground truth for what Ashe did. Every entry is a step card with an icon, a title, a subtitle, and a timestamp. Running steps show a spinner. Finished steps show a check. Blocked steps show a confirmation badge.

Expanding a step reveals the inputs, the model or tool name, the elapsed time, and the raw output. The feed is local, searchable, and exportable — so when a Hand does something unexpected, you can reconstruct the sequence exactly.

Which models drive agents?

Ashe picks a tool-use-capable model based on your device tier and the Hand's skill set. The default is a small, fast model; you can override per-Hand.

• Llama 3.2 3B — default on current-gen iPhones. Reliable tool calling, fast ticks, small memory footprint.
• Qwen 2.5 7B — deeper reasoning for Hands that plan across multiple tools. Enabled where RAM allows.
• Phi-3.5 Mini (128k) — long-context Hand model for log triage, digest drafting, and anything that ingests a lot of text per tick.

All three ship through Nimbus8's Hugging Face browser, filtered to the quantizations that actually run on your chip.

Getting started with Ashe

1. Install Nimbus8 from the App Store and mount a tool-use-capable model.
2. Open the Ashe tab. The empty Activity surface lists every connector — tap one to grant the matching permission or paste credentials.
3. Ask Ashe a small, scoped task: "Summarize today's calendar," "Read my unread email," "What's new in my feeds." If a tool needs setup mid-run, Ashe surfaces the matching connector sheet on top of the run.
4. Once one prompt works end-to-end, browse Hands and pick a starter — morning-brief and inbox.triage are the usual first choices.
5. Review the Hand's skill set and tick. Watch the first run in the activity feed. Approve any confirm-first prompts.

FAQ

Can Ashe run while the app is backgrounded?

Ticks fire when Nimbus8 is foreground or when iOS gives the app background time. Ashe does not use silent push, remote triggers, or server-side schedulers — on iOS, an agent that claims "always on" is almost always lying about the cloud round trip.

What happens if a Hand fails mid-tick?

The failure is written to the activity feed with the last step, the error, and the inputs that produced it. The Hand does not retry automatically; you retry it manually or wait for the next tick.

Can I write my own Hands?

Yes. A Hand is a small JSON-like document — a tick, a skill set, and a model — authored inside Ashe. Tool-use happens against the first-party skills shipped with Nimbus8; there is no third-party plugin loader by design.

Does Ashe share context with Gale or Cirrus?

Only when you explicitly route it that way. Context flows through the shared runtime but is scoped per-Hand by default. A Hand cannot read another module's chats or edits unless you grant it that skill.