Activity feed
Every tool call, every model call, every tick — written to a chronological feed you can scroll like a log. Expand any step to read the inputs, outputs, and timing.
Shipping · Ashe · Agent runtime
Hands that do things. On their own. On your terms.
Ashe runs scheduled "Hands" on a tick — small workflows that call tools and models locally, then stream every step into an activity feed you can read like a log. Writes, network, and disk are all gated behind a confirm-first policy, so nothing surprising ever happens in the background.
9:41
Ashe
Activity
Live tool calls, model calls, and hand ticks.
Hands
Uptime 2h 14m
Hands
Scheduled workflows you enable one at a time. Each Hand has a tick, a skill set, and a model — pause it, run it now, or let it wake up on its own.
Confirm-first
Writes to disk, outbound network, and destructive tools are always opt-in. Ashe pauses, surfaces the exact action, and waits for a tap before it proceeds.
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 basics most automations want:
- Calendar — read events, draft changes, propose invites (writes are confirm-first).
- Files — read and summarize documents in the app sandbox; writes are gated.
- Web — fetch a specific URL, summarize, extract. The network is off unless the Hand's skill set opts in.
- Shell — a sandboxed script runner for local-only transformations (no subprocess escapes, no PATH).
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.
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
- Install Nimbus8 from the App Store (coming soon).
- Open Ashe and pick a starter Hand — morning-brief and inbox.triage are the usual first choices.
- Review its skill set and pick a model the app flags as "fits your device."
- Enable the Hand. Watch the first tick 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.