Your tasks, your files, your agents and a browser. One window, on your own Mac.

Why a task first

Every piece of computer work starts from a task. A task has files and words going in, an agent session that does the work, and files and words coming out. No single application holds all three, so you carry the context between a task app, a file manager and a chat window.

Novel puts the task, the files, the agent sessions and a browser in one window, on your own machine, and keeps everything that happens there. The cycle it is built around: a goal, a project, a task; files and words in; a session as the work; files and words out.

Plainly: a local work OS for working with AI agents.

What it is

A Mac app with five screens, Tasks, Explorer, Sessions, Apps and Search, and a browser and a terminal beside them, over a local server that owns a permanent archive of every agent session. The sessions come from Claude Code, claude.ai, Cowork, Claude Code on the web, Codex, Grok and Cursor. Chats run from inside Novel through one harness against Claude, Codex, Grok, Cursor, local models through Ollama and Apple's on-device model. The same app opens on the phone over your own private network. Nothing leaves the machine unless you send it.

Who it is for

One person who works with many AI agents at once, on a Mac and from a phone, and whose work does not sit in one folder or one tool. No teams, no accounts, no hosted service. Novel is a single-user tool, and your own private network is its trust boundary, by design.

What it covers today: Claude Code in the terminal and in the Claude desktop app; claude.ai; Cowork in the cloud (local Cowork sessions are kept but no longer watched); Claude Code on the web; Codex; Grok; Cursor, for the runs Novel drives; Novel's own chats; local models through Ollama; Apple's on-device model; the iPhone.

The problems it answers

Each one is a thing you know from your own day, then what Novel does about it.

Agents delete their own history. Claude Code removes transcripts after a week; a cloud session deleted on claude.ai is gone; the desktop app deletes its own records. Nothing else holds the record of the work. Novel freezes a byte-verified copy of every transcript days before the cleanup can take it, and never deletes a row because a source file went away.

Sessions are scattered across agents, apps and machines. Each one keeps its own store, layout and format, some only in the cloud. Novel reads every one of them into one archive with one search.

Transcripts are not a clean record. They are rewritten in place, copied across forks and reconnects, and mix the harness's own text into your seat. A naive reader stores a wrong history. Novel's importer is built around those traps, with gates that count what they reject.

A folder does not say what a session worked on. Working directories vanish, sandboxes are one per session, and knowledge repos are used from everywhere. Novel pins sessions to the files they wrote, groups them by place and by area, and lets a file lead back to the turn that wrote it.

One conversation becomes many sessions. A continued, compacted, forked or carried conversation splits into pieces that the agents' apps show as unrelated. Novel folds a thread into one card and one feed, with the carry text built from the archive, not from a file that retention may already have taken.

Too many sessions, most of them stale or noise. The agents' own lists grow without end, headless runs and tests flood them, and a decision to archive or delete does not stick past the next sync. Novel derives a status ladder, sweeps stale sessions hourly, hides throwaway places, keeps deletes as tombstones that survive any import, and archives sessions in the Claude app itself, from Novel.

Finding it again. Past work across agents cannot be found by a word, an id, a note or the text inside a screenshot. Novel searches what the eye reads across every source, notes and file names included, reads the text in attached images on the device, and lands on the exact turn.

Slow and stale screens. A view that rescans transcripts waits seconds, and an open screen never learns that new work arrived. Novel imports a changed transcript within about two seconds and pushes the change to every open screen. No screen polls.

Many models, one place to run them. Each agent runs in its own app with its own controls, runs die with the window that started them, and a turn waiting for permission sits unseen. Novel runs every model through one harness with one composer, keeps runs alive past the request, and shows a waiting turn outside its tab, with a notification.

Away from the desk. Work goes on while you are away, and a desktop page does not work on a phone. Novel's phone app reads sessions, browses and edits files, starts and continues chats and answers permission prompts.

No shared task list between you and your agents. Tasks live in a third-party app with its own limits and polling, and you are the only memory shared between sessions. Novel keeps its own task store where every change names who made it, person or agent.

Pages agents build have no home. HTML pages and dev servers end up scattered across folders, with code that could reach the server. Novel keeps them on an Apps screen and runs them sandboxed.

Editing the files agents also edit. You and the agents write the same files, sometimes at once, and a viewer that cannot edit sends you elsewhere. Novel's editor records a save as your touch and refuses to clobber a file an agent changed meanwhile.

Agents with access to your machine and accounts. A chat that can write files and run commands, reachable from other devices, is a remote-execution surface, and a permanent archive keeps every secret that ever leaked into a transcript. Novel's answer is the Private pillar below.

Restarting a long session costs context and tokens. Novel's thread continuation builds the carry from the archive and keeps the harness lean, so a long session goes on in a new thread without the work being read again.

What is inside

Tasks, shared with your agents

Novel's own task list is the first screen: projects, sections, subsections, tasks and subtasks, in one local database with a journal of every change. You and the agents are in it together. Every change names who made it, comments carry their author, and an agent's write lands on the screen live, so the two of you talk over a task with no task app configured. Tasks carry the session that filed them. An agent can propose tasks with subtasks from a plan file or from a description; you review the proposal as a list, edit it, apply it or discard it, and revert an applied one. Seeded once from Todoist. The task tools reach Claude runs today.

Files first, sessions anchored on them

The Explorer is a real file manager over any folder: Columns, List, Tree and Tiles views, a split view, move and drag between folders, create, rename and trash, with the archive's anchors on every row: how many sessions touched it, its notes, the last touch. Select a file and a preview shows its content first, then the sessions that touched it, its history and its notes. The viewer reads text formats, images and PDFs in place. A file's History pairs the per-turn change-log with git commits attributed to session turns, so a file leads to the turn that wrote it. Notes stay with a file through moves and renames. The editor renders live, records a save as your touch and handles a conflict with an agent's write. From a row: read the text of an image on the device, summarise to a note, convert to a format, start a chat with the file. A folder of ten thousand entries opens without jank.

One harness, every model, on-device included

One composer runs every model: Claude through its agent SDK; Codex, Grok and Cursor over the Agent Client Protocol; Ollama models and Apple's on-device model through the same harness. One roster feeds every picker and the server validates against it. Four permission modes, Read-only, Plan, Manual and Auto, with an approval card per tool call, a plan approval that continues the chat, and a Local only switch that keeps a chat on the models of this Mac. Runs outlive the request; Stop stops; a turn that waits for you shows a needs-you mark on its card and a desktop notification. Files attach to a prompt. A chat starts from any allowed folder. A long session goes on in a new thread that carries its origin from the archive, whole, the last turn or one turn, with the cost in tokens shown before you send.

A browser beside the work

A web page beside the screens in the desktop window, in its own sandboxed session with its own sign-ins. The pages a session fetched or opened are listed with it and open in the pane. Drag an image out of the page and it lands in your folder. On claude.ai, the pane's Sync runs the claude.ai sync when you ask. Your own browser data stays apart from the agent's.

The permanent, verbatim archive

The archive is a pair of local database files, and the app owns no data of its own. Each transcript is frozen into a compressed, byte-verified copy at four idle days, ahead of the agent's seven-day cleanup, and its rows stay when the source file goes. Delete is your decision, kept as a tombstone, and it never touches the transcript file on disk. The rendered layer is only a cache over the archive. You own the log.

Every agent, one archive

One importer with an adapter per tool turns every source into one shape, so one archive and one search hold them all, with environment and model filters. Agent sessions sit beside Claude sessions, by folder.

Places, areas, threads and side sessions

A project is a place: an area you authored, or the folder bucket of sessions with no area. A continued session names its origin and lists fold the thread into one card, within one environment; a session the Claude app started from another folds under its parent. Any session can be continued as a new thread from Novel, carrying the origin from the archive, whole or one turn. Areas are managed as a list.

One search over everything

One query, one answer, every facet behind six tabs: everything, files, sessions, tasks, apps and notes. Exact and ranked modes over what the eye reads; tool output searchable only when you ask. A hit opens the session at its turn. Cmd+K from anywhere. The answer follows the push stream.

The phone, over your own private network

The same app, added to your home screen, with no address bar: the explorer, viewer and editor within the sidebar's places; sessions full screen; start, continue and thread chats; answer approvals; open your apps. No desktop notification there.

Apps, for what agents build

The HTML files, folders and local web apps you keep, with their live state, opened in a dialog or a tab; dev servers mounted by port; an HTML page an agent wrote runs in a sandboxed origin that cannot reach the server's gated routes. Reachable from the phone.

Live, without polling

One sync loop owns freshness: a change watcher imports a changed transcript within about two seconds, a periodic sweep reconciles, and every open screen follows one push stream. Nothing imports inside a request and nothing adds a timer.

Local, private and safe by construction

The server listens on the loopback address and is reached from other devices only over your own private network. Mutating routes are origin-gated, and the chat and file-writing routes take a token. Write-capable modes sit behind a gate re-checked every turn; a chat's folder is contained; no run loads the claude.ai connectors; provider keys never cross between agents. With no internet the core still works: the archive, notes, files, local models. In the run captured on 16 October 2026, a Local only turn opened no connection beyond the machine, within the capture's stated limits. Redaction exists for a secret that reached a transcript.

Usage kept honest

Billed tokens come from an exact per-call ledger; estimates are labelled as estimates; the two never look alike; no price is computed anywhere. The ledger lives in the archive; its views in the app are a port still to come.

What Novel is that other tools are not

• Tasks, files, agent sessions and a browser in one window.
• It reads the agents' own transcripts on your disk and keeps them past the agents' deletion.
• One place where sessions from every agent you use today meet, and a session from one environment continues in another.
• The agent's browser holds none of your personal data.
• The apps agents build live in your own folders and open without a chat, from the phone too.
• Lean context: Novel gives a run its own small tool set instead of every plugin in every session. A cold Novel chat's first call reads about 33,000 tokens, against about 73,000 for a Claude desktop session with its plugins and connectors loaded (medians over the author's own sessions of 9 to 22 October 2026).
• Run Novel on the machine that has the models and use it from your phone over your own private network.

Measured on the author's own archive

What is next

A free downloadable version with limited features.

How it was made

The product page told you what Novel does. This part is for the reader who wants to know how it was built, by one person, with agents, in the open of its own archive. I lead with the process, because the process is the claim.

The problem

Sessions with many agents pile up in tools that delete their own transcripts, and files and conversations live apart. Claude Code keeps a transcript for a week. A cloud session deleted on claude.ai is gone. The desktop app deletes its own records. Across Claude Code, claude.ai, Cowork, Codex, Grok and Cursor, nothing held the record of the work, nothing said which files a session had touched, and a continued conversation showed up as unrelated pieces. I was the only memory shared between my sessions.

The constraints

One person, one Mac, local and private by construction. The vendors' stores shrink and rewrite themselves: transcripts are not append-only, a turn can delete lines mid-file while appending at the end, and retention windows move. The trust boundary is my own private network, a decision I wrote down rather than a gap I hoped nobody would notice.

The approach

Archive first, then files, then tasks. One sync loop for freshness and a push stream instead of timers. A client that owns no data: the app asks the server for JSON and never opens the database. Specs as the contract for what the code does today. Agents as the build crew, with a human deciding.

The story, with dates

The idea is older than the code, and it is two ideas. In spring 2023, as I remember it, I wanted a to-do app where every task has a button that does it for you and another that breaks it into subtasks, for ordinary people and everyday tasks, not for developers. The earliest written trace is from 3 June 2025: one AI app for tasks, events and notes, with clipping into a knowledge base and agents that carry tasks out rather than list them. In February and March 2026 I looked at how AI browsers and modern browsers are built. On 15 April 2026 I stated the second idea in full: a macOS app that joins a web browser, a local file explorer and a knowledge layer in one window, with tabs for both, one shared history, a permissioned bridge between them, and context collected along the way.

Three lanes ran toward one goal. Pulse, a rewrite of a session engine in a second language, parked in June 2026 with its name undecided. CSessionsV, a native desktop fork with a self-update loop, parked in July with its first milestone built on an unmerged branch. And CSessions, the one in daily use, which became Novel.

June 2026, the viewer. A sessions index on 6 June, because the desktop app's recent-sessions list was impossible to navigate and most of it stale. A viewer reachable from the phone over my private network on 7 June, live within half an hour of the ask. The first commit on 11 June. By the end of the month: a modular server, the first chat from the viewer, a file explorer and a session page. Sessions first.

July 2026, the archive. Surfaces on 22 July, born in portfolio work as a hub for goal-bound sessions across directories, built as a graph with the turn as the row. Three days later I redefined the base concepts: one database as the single source for the whole app. It became the archive pair on 25 July, with its first backfill and its retention gate. Then the Cowork and claude.ai adapters, the connections layer, notes.

August 2026, the archive month. Freezing. The finding that transcripts are not append-only. The per-file change-log and a Versions view over git with turn attribution. A second machine as a source.

September 2026, sources and tooling. Tool-call cards, cost and usage views, tool-output search. A machine wipe survived with the archive intact. The claude.ai live sync, cloud Cowork, and the rescue of a server-side session list on the afternoon it was deleted. Notes search. On-device OCR of attached images. From 22 September the task tooling grew beside the archive: a Todoist CLI, agents per task, a brief agents read first, planner and executor roles.

Early October 2026, live. The speed and live-sync work: one sync loop, a change watcher, a push stream, threads and compaction breaks, the single-writer lock.

7 to 8 October, files first. In one evening I wrote the direction down: the terminal agent is for developers only; the chat client with a sidebar of recent chats is useless for projects; the agentic IDEs are the right shape but built for code. What I wanted was content first with agents anchored on it: a complete file explorer, then a built-in browser, with a harness and a roster including on-device models. It was drafted, approved and committed within eight hours, with a written exit: build the explorer as the one feature of a spike, and stop if it does not feel right as the home screen. The first app code landed three hours later, and the explorer, sessions, details and search screens within about seventeen hours.

9 to 10 October. Every model moved to one harness. Chat in the app. The phone ran the app. The server-rendered web UI was deleted whole and frozen as a reference clone. The product got its name: Novel.

13 to 15 October. Codex, Grok and Cursor over the Agent Client Protocol. The freeze moved ahead of a shortened retention window. Specs split, and decisions moved to one file each. Tabs in the title bar, previews first after a same-day reversal, the Tasks screen and the agents' task tools. Four hours after the Tasks screen landed, a day of brainstorms and a one-prompt-many-models council on how surfaces might connect tasks, files and chats ended in the tasks-first message: files are the input and the output of a task, never the origin; the origin is a goal.

The night of 15 to 16 October. One session was handed the backlog with one instruction: take every task that needs no decision from me. It ran parallel build, review and land triples in worktrees across nineteen lanes and merged eighteen of them into main before dawn, the browser pane among them, with the areas screen, share links, side sessions, note editing, the live tail, the partial carry, one thread definition, search on the push stream and the global jump. The next day went into checking the result.

The pivots, told as pivots: sessions first in June; surfaces as the connective tissue in July; files first as a working choice with a written exit on 8 October; tasks first on 15 October. Each premise is my account, and the dates are the repository's and the archive's. Tried and retired on purpose: a reply feature, built as an experiment and retired for thread continuation; a hide-and-restore pair; a details dialog, replaced by tabs; the web UI itself.

The method

Specs hold current behaviour, and only that. A behaviour change updates its spec in the same turn. A spec over a size cap becomes a folder with an index on top. Each carries a last-verified stamp.

One decision per file. 119 records by 23 October 2026, each with its context and its cost, superseded by a new file and never edited. Four that show the shape: the shell choice; loopback with private-network-only exposure; the single writer as a lock, not a convention; and the same-day loop where tabs on click were reversed into previews first after I called the change unrequested.

A per-turn change-log, one file per month, each entry stamped and ending in the specs it changed. A docs gate checks sizes, indexes, dead paths, generated blocks, the same-turn rule and the stamps. A weekly spec gardener re-checks the specs whose cited code changed, on its own branch, filing a review task and never touching main. Its limit, stated: it checks form, not truth.

Test gates on temp data for the server and the app, and an end-to-end gate that drives the built app in named parts picked from the diff, with a phone-size window and performance bounds. The honest caveat: the whole gate runs only when I ask, and the record says when it was not run.

Equivalence proofs at migrations. When the list moved from the old UI to the app, the endpoint stayed byte-identical over every query combination tried.

Built through agent sessions, and audited after. From 8 October to 22 October, 351 sessions built the app, their sub-agents apart. Each unit's transcripts were exported from the archive and read by an agent that checked every commit against git and every file against the tree, and kept an Unverified list of claims nothing on disk proves. Parallel builders in worktrees with verifiers and a merge session; and a rule, born from a collision, that parallel sessions take disjoint screens, shortcuts and spec sections.

Self-critique on the record. A roast written four days after the cutover priced the weak parts: a router with no route table, oversized and stale specs, a test record of self-reports, a convention-based cache contract, the trust boundary, the shell carrying a pane not yet built, large files, five names for one thing. Within days the route table was generated from the code, the specs split, decisions got files, the gate and the gardener existed; the pane was built within four. What stays open is listed, not hidden.

Measured first. Rules carry the dated measurement that earned them; plans mark claims as measured, read, reported or inferred; agent modes ship only where a probe held.

Directed, not delegated. Many of the UI choices are recorded in the specs as my call, with the date.

Three stories

A silent corruption of a fraction of a percent. A line-accounting gate found it, and a whole-prefix hash plus a bounded read closed it.

The retention gate as a staged risk decision. Before the agent's cleanup window shrank, the archive was checked frame by frame, and a forensic account established who had removed thirteen transcripts.

The rescue. A server-side session list was deleted one afternoon; by evening its sessions were in the archive.

The overnight run

One thread of two sessions, handed the backlog with one instruction, ran agents in build, review and land triples over nineteen lanes, with eighteen merges into main between about half past four and six in the morning of 16 October, checked by the whole gate later that day. It closed 17 tasks. The product's own thread model, task store and archive made the run traceable: a task can be followed from the session that filed it, through the sessions that saw it, to the session that closed it and the merge it names.

A smaller example: the restart study. Five agents over the archive answered which restart is cheaper for an agent, corrected by their own continuation sessions, the product's thread model used on itself.

What the record shows about how I work

Verify verbatim and reconcile counts: the byte-verified frames, the byte-identical migrations. Let determinism do the structured work and spend the model only where judgment is required: connections are deterministic before statistical before models, with no model sweep over the corpus. The structural instinct firing first: the data model, places, areas and threads were defined before any screen. Build the tools, ship them, package them. Ship through AI tooling and rebuild from scratch when the quality fails the bar. The pipeline-builder half of the job is what lets the designer half move at this speed.

What was learned

The roast and what it changed. The corruption a gate found. Previews first, after a same-day reversal. Replies retired. The premise changed three times, and the record says when and why each time.

What is next

A free downloadable version with limited features. Then the task-first architecture built through, with the join from a task to the session that worked it written at launch, and the task's do-it button that starts an executor agent. A scheduled claude.ai import, eventually.

Ideas on the table as of October 2026, none of them planned: an agent that executes a comment left on a file; the agent's own accounts kept in Novel's browser; editing a picture dragged out of the browser with AI; a video in picture-in-picture beside a chat; every HTML file recognised as an app on its own; a home screen for the day; generative interfaces.

About the author

A principal product designer with over twelve years of experience, working two identities in parallel, neither a side project: the designer, whose outputs are visuals, interactions, systems and specs, and the pipeline builder, whose outputs are tooling, prompt scaffolds, workflows and automation that make design work cheaper, faster or higher fidelity. He builds the tools he needs, ships them and packages them; he ships through AI tooling with his own overrides; taxonomy, information architecture and the data model come before any visible UI. He uses Novel himself, full time, reads his own history through it, moved his tasks into it, and built the app with agents inside the app's own archive.