Product

An agent, fully specified.

Morrow is being built as a complete personal agent — not a chat box with extras. Here is the whole shape of it, with each part marked for what exists today and what is still ahead.

The intended experience

A plan you can read, an execution you can watch.

Task planning and execution sit at the centre of the product. This is how it is designed to feel.

Quarterly review
Local modelWorkspace · ~/review
plan.jsoninspected
1{2  "goal": "Prepare the quarterly review",3  "scope": "~/review",4  "steps": 45}

Privacy

Workspace scope set to ~/review · 4 files. Nothing read yet.

Evidence

plan.json
01 / 05

Step 1 of 5: Plan the work.

The whole product

Ten parts, one coherent agent.

01

Conversations and projects

In progress

Give every thread a home, and every project a memory of its own.

Conversations live inside projects that carry context, files, and history — so picking work back up never starts from zero.

Status Basic project and task persistence exists; the connected interface is being built.

02

Task planning and execution

In progress

Turn an intent into a deterministic plan you can read before it runs.

Morrow drafts a plan in explicit steps, advances through clear states, and shows what it is doing as it does it.

Status Persisted task lifecycle and task events are under active implementation.

03

Persistent agents

Planned

Named agents that are accountable — role, model, memory, and limits.

Each agent has a defined scope, its own tools and permissions, a cost ceiling, and an activity history you can audit.

Status Designed in detail. Implementation follows the first reliable vertical slice.

04

Structured memory

Planned

Remember deliberately, not silently.

Typed memory with explicit scopes and retention — every read and write is visible, and nothing is absorbed by accident.

Status Specified. Built after secure tool execution lands.

05

Tools and permissions

Planned

Capable actions inside boundaries you understand.

Browser, terminal, and file tools run under per-action permission scopes, against an explicit workspace — never the whole machine by default.

Status Secure workspace inspection is in progress; broader tools are planned.

06

Automations

Planned

Let routine work happen on its own — without losing the thread.

Schedules and event hooks trigger plans within set boundaries, and every run leaves the same evidence a manual run would.

Status Planned. Depends on reliable execution and scoped tools.

07

Model routing

Planned

The right model for the task — local or approved remote.

Route per task between local inference and approved providers, with the active model and its boundary always shown.

Status Planned. Provider adapters arrive in the model-providers stage.

08

Customization Studio

Planned

Make deep control approachable — not a config-file scavenger hunt.

Visual control over agents, models, memory, tools, autonomy, interface, and privacy, layered over presets that already work.

Status Designed across three tiers: Presets, Studio, and Developer mode.

09

Evidence and history

In progress

Every meaningful action should leave evidence.

A durable timeline of what ran, what changed, and why — with the artifacts to verify it after the fact.

Status Task events and recovery are in progress; full evidence views are planned.

10

Recovery and rollback

In progress

Fail visibly, recover honestly, and undo what should be undone.

Plans persist across restarts, checkpoints make work resumable, and reversible actions can be rolled back deliberately.

Status Restart recovery and checkpoints are being implemented in the vertical slice.

Customization Studio

Deep control, made approachable.

Three layers — each a deliberate step further in, never a wall you hit by accident.

01

Presets

Start in minutes

Polished configurations that work without setup. Sensible models, memory, and boundaries out of the box.

02

Studio

Shape it visually

Visual control over agents, models, memory, tools, autonomy, interface, and privacy — no files required.

03

Developer mode

Go all the way down

Skills, APIs, MCP, custom providers, event hooks, and configuration files. The full surface, on purpose.

Early, and honest about it.

Capabilities here describe what Morrow is being built to do. Follow the build to see them land, or join early access to help decide what lands first.