Nitish Prasad

SproutCrew — the review board for your AI agents

SproutCrew is a Mac workspace for people who write, research, and develop ideas. Bring a brief and your sources, give the crew your audience and voice, approve its plan, and review the work before exporting it.

My role
Product design, architecture, AI-assisted engineering
Built for
People who already run AI agents
The workflow
Brief → plan → draft → check → revise
Status
Free macOS public beta · 2.1.0 · Apple Silicon

1.1

From interview notes to a newsletter

Consider a product manager who has customer interview notes and wants a 500-word newsletter for the team. The piece needs a clear point of view, the right voice, and claims that can be traced to the supplied notes.

SproutCrew keeps the brief, sources, plan, drafts, and checking passes together in one project. The crew is a set of writing and checking roles that the person can inspect and configure. The same workspace also supports proposals, research briefs from supplied sources, and brainstorming.

The aim is a finished piece the person can edit and review. Here is the user journey for this illustrative example; the engineering sections below explain the controls behind each step.

  • Bring the context: add the interview notes, describe the audience and length, and save voice preferences in shared project memory.

  • Review the plan: see the outline, draft, edit, check, and final-revision steps, choose the models, then approve the work.

  • Shape the result: read the draft and checking pass, ask questions, and rerun a step with feedback when it needs another pass.

  • Take the work with you: export the finished text in a supported format, such as Word or PDF, and make the final decision about sharing it.

Example brief

“Turn these customer interview notes into a 500-word newsletter for product managers. Keep a direct, warm voice. Cite the notes, label assumptions, and flag anything that needs more evidence.” This is an illustrative brief. Live-model evaluations are addressed separately in the release checks.

1.2

A backend on the Mac

Supporting this user journey means coordinating context, ownership, cost, and review across multiple steps. I designed the product and built it with AI-assisted engineering, keeping that coordination in a local Rust backend.

The backend runs inside the desktop app. React and TypeScript render the interface; Tauri commands cross the native IPC boundary; a Rust application layer owns planning, dispatch, sources, artifacts, and approvals. The UI does not persist provider credentials or call inference APIs directly.

Cloudflare is the distribution layer: the product website runs on Pages and release files use R2. It is not a hosted inference backend. Requests leave the Mac over HTTPS to the selected provider. OpenRouter forwards inference to an upstream model provider.

On the Mac

  1. React + TypeScript

    Brief, plan, sources, memory, review, and usage screens. Vite builds the interface.

  2. Tauri command boundary

    Typed command arguments enter native handlers. Progress returns through an IPC channel.

  3. Rust application + core

    App → Studio → RoutedEngine → ApiEngine. Local policy checks precede provider requests.

SQLite
Logical events and rebuilt state
Project files
Sources, artifacts, checkpoints, traces
JSON
Editable notes and route settings
macOS Keychain
Provider API credentials

HTTPS
Selected context

External services

Inference APIs

OpenRouter first; direct OpenAI and Anthropic alternatives. Selected context leaves the device.

Cloudflare Pages + R2

Website and versioned release delivery. Separate from project execution.

Project storage is local. Inference is remote. There is no SproutCrew account or built-in cloud project sync.

Architecture and trust boundaries. UI actions enter Rust through Tauri IPC. The native backend manages local state and sends bounded requests to fixed provider endpoints; Cloudflare serves distribution assets separately.

1.3

A workflow with explicit gates

Agents are roles in a plan, not separate cloud services. Each role has a route, model, effort setting, and step guide. The writing workflow is outline → draft → edit → check → final revision. A single connected provider can perform both writing and checking, but that is a second pass rather than independent verification.

Approval binds a canonical SHA-256 hash of the plan and execution scope: role/tool policy, source snapshots, selected capabilities, budgets, routing and request bounds. Material changes require fresh approval. The Rust core checks Allow / Ask / Deny for app-owned actions; reviewer roles remain read-only and shell stays denied. Provider output cannot grant authority. This is application-level enforcement, not an operating-system sandbox.

A cross-project Decision inbox collects plans, action requests, findings, escalations, code diffs and failed steps. A native watcher updates its count and can request grouped, generic Mac alerts while the app is in the background. Clicking an alert opens the inbox; it cannot approve work. Permissions, Focus and screen-sharing settings still control actual OS delivery.

  1. Describe and plan

    Choose a workflow or request a plan through a connected API.

    Inspect the control

    Validate roles, stage IDs, dependencies, routes, and models. An API-generated plan cannot silently switch to an unrequested route or model.

  2. Approve the exact scope

    Bind approval to the canonical SHA-256 scope hash.

    Inspect the control

    The plan, role/tool policy, sources, capability choices, budget and provider settings are part of the approved scope. A material change closes the dispatch gate until fresh approval.

  3. Dispatch a ready step

    Check dependencies, stop state, and allowance before sending context.

    Inspect the control

    Build bounded context, reserve usage, and create the task's trace. In-flight workers share spending books and a stop latch.

  4. Collect and check

    Register the artifact version; attach review findings to its content hash.

    Inspect the control

    A review for an old or unknown artifact version is refused. A material revision invalidates earlier reviews; a checking report cannot edit the artifact through its report path.

  5. Revise and export

    Apply findings, retain open questions, and export the finished work.

    Inspect the control

    Rust parses the scanned text into typed blocks. docx-rs makes Word files, PptxGenJS makes PowerPoint files in a bounded local runtime, and Typst makes PDFs. The person still checks claims and decides whether to share the result.

Execution lifecycle. Open “Inspect the control” on any step for the actual gate behind the interaction. The diagram describes implemented behavior, not a live AI run.

1.4

Memory that survives the next agent

Shared memory is an explicit instruction layer. Project-wide notes live in notes.json; a note can also target one step. Every subsequent run rebuilds context from the current notes, so a writer and a checker can receive the same audience, voice, and decisions after the app reopens.

This is not a vector database or autonomous learning system. There is no automatic cross-project memory. Editing validates the replacement before saving it through a temporary file and rename, while preserving note identity and scope. A damaged notes file is an error rather than an empty list that can be overwritten.

Instructions and source material have different roles. User notes sit with the step's instructions; files and earlier results are bounded data blocks with source IDs and truncation markers. That makes the trust distinction explicit; it does not guarantee immunity from prompt injection.

Project memory

Audience, voice, and decisions. Editable notes scoped to the project or step.

Step instructions

The brief, role guide, project rules, and selected skills.

Source evidence

Supplied files, public pages, and relevant earlier results. Kept distinct from instructions.

Rebuild context before each run

Context builder + trace

Bound source size, mark omissions, record input IDs and hashes, and capture the notes supplied to this task.

Selected context is sent with the API request

Writer / editor / checker

Each receives the current relevant instructions. The next agent need not rediscover the user's preferences.

Local run record

Route, model, effort, source hashes, notes, and resulting artifact hash make the run inspectable.

Persistent context, not hidden global memory. Notes are stored on the Mac and transmitted when included in model requests. Removing a note does not erase historical traces or earlier results.

1.5

Provider routing and cost controls

The public candidate constructs API engines only; subscription CLI routes are disabled. Read-only provider endpoints validate keys before Keychain storage. The Rust HTTP client uses fixed provider hosts. The interface explains that API billing is separate from a consumer chat login.

Every request reserves an estimated worst case before dispatch. A shared spend book coordinates concurrent work across routes and projects. UTF-8 byte estimates conservatively bound input usage. New key connections count tokens unless explicit pricing is configured. Provider-reported dollars are retained as a separate reading, without settling token reservations or implying a dollar cap; missing dollar reports remain unknown. A token allowance is not a dollar spending guarantee.

For OpenRouter's free route and explicit free variants, requests set zero prompt, completion, and request price ceilings, disable provider fallback, and deny provider data collection. If no eligible endpoint is available, the request fails. A person must deliberately select a paid model to use that route.

  1. Estimate

    Bound input, output, and configured tool costs before a call.

  2. Reserve

    Hold the request's worst case against the shared allowance. Refuse it if it does not fit.

  3. Send and settle

    Use the fixed endpoint, then reconcile known usage or preserve uncertainty.

Known usage
Settle the reservation from reported usage; release unused headroom.
Refused / unsent
Release the reservation when the request was not sent or was explicitly refused.
Uncertain billing
Count the full reservation and stop automatic fallback. Do not turn missing usage into zero cost.
Request allowance lifecycle. App-side accounting limits exposure, while provider billing controls still matter. An already-sent request may complete or be billed after a stop request.

1.6

Recovery and artifact integrity

SQLite stores append-only logical events. The journal uses write-ahead logging and full synchronization settings; application state and usage projections are rebuilt when a project reopens. This is inspectable local history, not a tamper-proof audit log.

Project directories separate task work, promoted artifacts, and checkpoint manifests. SHA-256 hashes identify source inputs and artifact versions. Ownership and stale-base checks prevent an old revision from silently replacing the current artifact, and material changes invalidate reviews of earlier content.

Tauri is a thin native command layer over the Rust application core. Provider transports are injected behind a small interface, allowing workflow and failure tests to exercise complete workflows without paid API calls. Keeping those boundaries explicit makes the backend testable without driving the desktop UI.

Implementation map

Desktop boundary: crates/bff-app/src/main.rs. React-to-native calls: ui/src/api.ts. Workflow coordination: bff-core/src/app.rs and flow.rs. Provider execution: engine.rs, api_engine.rs, and apiroute.rs.

State and evidence: journal.rs, workspace.rs, artifact.rs, review.rs, context.rs, notes.rs, and trace.rs. Shared usage accounting: reserve.rs and spend.rs. Packaging: scripts/release-mac.sh, notices.py, and fetch-helpers.sh.

1.7

Local files without a conversion service

The writing workflow ends with files the person can keep and edit. Word generation uses docx-rs in Rust. PowerPoint generation uses PptxGenJS inside a fresh embedded QuickJS runtime; the same Rust application core owns direct exports, final-file caching and portable packages. Users do not need Node, Pandoc or a cloud document-conversion account.

Markdown becomes typed blocks and spans before rendering. The app passes JSON data to fixed JavaScript layout code; model output is never evaluated as code. The embedded runtime has no filesystem, process or network bindings, with explicit heap, stack, time and slide-count limits. Word and PowerPoint preserve editable text and tables. Typst remains the PDF engine, with client documents using the same parsed structure for tables, links and list numbering.

The export path scans complete inputs before writing, refuses existing destinations and records file hashes and sizes in the package. Images remain labelled references rather than being fetched from a model-supplied URL or local path. Run reports retain a separate conservative Markdown/PDF renderer. These choices trade broad converter compatibility for a smaller, explicitly scoped local export surface.

Export boundary and fixtures

Implementation: office_export.rs and clientfiles.rs; pinned Office JavaScript and notices under export-js; Typst helper calls in typst.rs. PowerPoint uses 128 MiB of JavaScript heap, a 2 MiB stack, a 30-second deadline and a 250-slide limit. The renderer exposes no host I/O API. This does not give generated shell commands an execution sandbox.

A synthetic app-core fixture exercises client exports, cached final files, decision log, Markdown/PDF run report and the full portable package with zero provider requests. All 39 packaged file hashes and sizes were checked. Word and PowerPoint opened the corrected fixture files without repair prompts, and both applications reported Accessibility: Good to go. XML checks and that fixture result do not establish perfect formatting for every possible document.

1.8

What the release checks establish

The 8–9 November 2026 check run recorded 1,052 passing Rust tests and 66 passing UI tests, with two live-web tests intentionally ignored. Fixture checks include action-policy enforcement, failed-attempt report history, attention grouping and duplicate suppression. An earlier simulated-HTTP integration completed the five-step writing flow, edited memory, reopened the project, and exported the final Markdown. This is not a live-model quality benchmark.

The macOS 2.0.5 app and DMG, a universal build at the time, were signed, notarized and stapled, and passed signature and Gatekeeper checks. The exact quarantined installer copy was observed under App Translocation with its 8 November 11:48 PM build identity. Native preflight and retained connections/results passed. It generated Word, PDF and PowerPoint client files, a Markdown/PDF run report, a decision log and a 24-file package; all package hashes and sizes matched, with no missing or incomplete parts. This local QA used existing results and made no new model requests. The installer is 64,821,744 bytes, down from the preceding 131,192,807-byte candidate, and contains no Pandoc. Exact MPL dependency sources and signed-app notices are prepared locally. These checks do not establish fresh-user behavior.

The saved OpenRouter key worked. Dashboard upstream logs identified Google AI Studio 429s on both free-router attempts. A separately approved check then completed all five synthetic writing stages on GPT-4.1 Mini through OpenRouter/OpenAI, with $0.009346 reported. Successful generation records matched the app. The earlier failures remain visible, and the original configuration was restored without resetting history or retaining approval. Five same-model steps are a mechanics check, not independent review or a writing-quality benchmark: the final text was about 441 words against a 500-word brief, and used generic phrasing. On 9 November the owner reported delivery in Notification Center and confirmed that clicking the notification opened the Decision inbox. A desktop banner was not observed. A separate Apple Silicon/Chrome test, relayed by the owner, confirmed normal first opening, an empty project list with no saved API connections, passing non-API preflight checks and persistence after completing Create project. The unfinished setup form does not autosave. Finder displayed Replace on the first copy despite the fresh app-data state; the exact cause remains unknown, and read-only DMG inspection found the normal Applications shortcut. The 2.0.5 free public beta followed, with exact installer, notices and dependency-source downloads. Since 17 November 2026 the public download is 2.1.0, built for Apple Silicon only; Intel Macs are not supported. Live-model quality remains unverified.

Engineering tradeoffs and next checks

A local backend avoids operating a central project-data service, but makes macOS packaging, native credential storage, and cross-architecture verification part of the product. API-first routing simplifies the public access model, while adding key setup and provider billing friction for users.

Explicit project notes are easier to inspect and correct than automatic global memory, but require the person to decide what persists. A second model pass adds scrutiny; using the same provider does not establish independence. Automatic web search and computer control are unavailable. Advanced code roles can stage worktree drafts for exact-diff review; dependency installs, generated shell commands and tests remain blocked without proven isolation.

2

Contact

Hiring for a product area?

I am looking for Principal / Staff IC ownership of a product area.

Download résumé

hello@nitishprasad.com