Rescriptum

Native agent IDE

The self-verifying native agent IDE.

Automatic build verification, deep symbol indexing, and instant checkpoint rollbacks on broken edits — built into a fast native desktop application. BYOK via OpenRouter.

Native Desktop·Windows 10 / 11 (x64) · v0.7.0 Live·Ask · Agent · Plan · Build

Download Windows ClientDocumentation
18.4K · $0.08
routes.ts
Agent
routes.ts
import { rateLimit } from "../middleware/rateLimit";
 
export async function handleRequest(req: Request) {
const limited = await rateLimit(req, { windowMs: 60_000, max: 100 });
if (!limited.ok) {
return new Response("Too many requests", { status: 429 });
}
 
const session = await authenticate(req);
if (!session) {
return new Response("Unauthorized", { status: 401 });
}
 
return routeHandler(req, session);
}
patch_file · src/api/routes.ts

Interactive preview — explore sidebar, files, and chat like the desktop app.

Core Capabilities

Three pillars of Rescriptum

Rescriptum isn't just a chat box in an editor. It's a complete agent workspace with verification, memory, and cost discipline built in.

01

Build gates & instant rollback

Verification & Safety

Every file edit is guarded by an automated build and diagnostics verification gate. If a change fails tests or breaks the build, Rescriptum can immediately restore your last clean checkpoint. Commands run in isolated sessions with configurable approval rules.

  • Automated build verification & instant checkpoint rollback
  • Git worktree isolation for parallel agent branches
  • Strict, balanced, or permissive tool approval presets

02

Context that compounds

Codebase Intelligence

Deep symbol indexing extracts functions, types, and call graphs before the first edit. Persistent project memory, learned conventions, and live documentation research keep agents accurate across sessions.

  • Instant symbol search & codebase structure mapping
  • Cross-session project memory & learned conventions
  • Live documentation & web research with source citations

03

Fast desktop with zero markup

Native Speed & Economics

Designed as a lightweight native desktop application with instant startup and minimal memory footprint. Connect 300+ frontier models via OpenRouter with zero inference markup, live token treasury tracking, and daily budget controls.

  • Instant native startup & low memory footprint
  • Live token treasury & daily spend controls
  • 300+ models via OpenRouter with zero markup
BYOK OpenRouter — inference billed by the provider, not Rescriptum.

Workflow

Four modes, one engine

Ask for quick guidance. Plan without risk. Build with intent. Agent when you want the full loop.

Agent mode

Full autonomy with guardrails

Read, write, patch, run commands, MCP tools, and verify. Default mode for fixes, features, and exploration.

TOOLS this round
read_filepatch_filerun_commandget_diagnosticsverify+ MCP tools

Agent observability

Edit, verify, log. Recovery when tools fail.

Verify runs after edits and surfaces in rollout logs. The editor path prioritizes flow — failed gates become advisory notes on turn_complete. Copilot workers can run with stricter autonomous gates.

Happy path
patch → diagnostics → test → turn_complete
round 1…
rollout.jsonl · debounced verifyclaude-sonnet · $0.11
Loop recovery
patch fails → guardrail → write → verify
round 1…
rollout.jsonl · debounced verifyclaude-sonnet · $0.11

Verify gates

LSP diagnostics, scoped typecheck, and build/test after edits. Debounced so rapid patches don't spam CI.

Turn completion

Model signals done via turn_complete. Gate results attach as notes in editor mode; workers can enforce harder stops.

Rollout logs

Full JSONL trace per turn: every tool call, cost, and round for debugging and audit.

Cloud dashboard

Usage synced from the IDE

Sign in with the same account in the desktop app. Costs, models, and workspace activity update after agent turns — typically within ~60 seconds.

  • Token and cost breakdown by model
  • Per-workspace activity from usage logs
  • Device heartbeat when signed into desktop
Open dashboard
Example layoutlive when signed in
Tokens
2.4M
illustrative
Cost
$4.12
illustrative
This week
Model mix
deepseek-v4-flash 42%claude-sonnet 28%gpt-5.5 18%others 12%

Trust & safety

Serious agents need serious guardrails

Autonomy without oversight is how repos get deleted. Rescriptum layers policy, approvals, and isolation so you can delegate real work.

Terminal security

Hard-deny catastrophic commands (rm -rf /, $HOME, .). Chained shell parsing. Shell substitution blocked on approval-protected ops.

Tool permission presets

Strict, balanced, or permissive defaults in Settings. MCP tools, git push, and deletes can always require approval.

Worktree sandboxing

Agent edits on isolated branches. Review diffs, run verify gates, merge or discard. Main stays safe.

Transparent rollout logs

Every tool call, round, and cost in JSONL. Debug agent behavior without guessing what the model did.

Use cases

Built for real repo work

Multi-round agent sessions on production codebases, not autocomplete demos.

01
Debug

Fix failing tests without a 27-round spiral

prompt › Tests fail on auth middleware. Find root cause and fix.

result › 3 rounds · patch + diagnostics · tests pass · turn_complete

02
UI

Redesign a dashboard with live preview probes

prompt › Make the analytics page responsive. Match the design system.

result › worktree branch · UI verify · Tailwind density check

03
Scaffold

Ship a feature from a Plan → Build workflow

prompt › Plan a webhook ingestion API, then implement after I approve.

result › Plan mode recon · Build mode · verify gates on each file

04
Isolation

Risky refactors in git worktrees

prompt › Migrate the terminal backend to PTY. Don't touch main.

result › agent worktree · review diff · merge or discard

Live Browser CompanionPersistent Project MemoryVisual UI Verification

Platform

What ships in Rescriptum

Native agent infrastructure for serious repo work — not a chat overlay on an editor.

Verification & Safety

  • —Automatic diagnostics & build checks after each edit
  • —One-click checkpoint rollback to any previous turn
  • —Isolated command execution with directory guardrails

Codebase Intelligence

  • —Deep symbol search across TypeScript, Python, Rust & Go
  • —Precision multi-file diffing and conflict prevention
  • —Automatic project structure indexing on workspace open

Multi-Agent Workflows

  • —Parallel subagent delegation (editor, reviewer, researcher)
  • —Isolated git worktrees for safe parallel exploration
  • —Strict, balanced, or permissive tool approval presets

Desktop & Browser Ecosystem

  • —Fast native desktop client with instant startup
  • —Rescriptum Tab browser companion for live DOM & QA inspection
  • —Curated Light, Dark & Custom Vault workspace atmospheres
0+
Frontier AI Models
Via OpenRouter BYOK
0%
Inference Markup
Direct provider pricing
Native Desktop
Instant Startup & Low RAM
Windows 10 / 11 (x64)

Pricing

Simple, transparent pricing

Start free with your own key. Pro adds cloud features when billing ships — the IDE stays fully usable on Free.

Beta

Free

$0/mo
  • Full IDE — all agent modes
  • BYOK via OpenRouter
  • Local treasury & rollout logs
  • Cloud usage dashboard when signed in
Coming soon

Pro

$19/mo
  • Extended cloud analytics
  • Priority model routing
  • Cross-device preferences sync
  • Email support
Notify me

Enterprise

Custom
  • Self-hosted deployment
  • Custom model endpoints
  • SSO & team management
  • Dedicated support & SLA
Contact sales

Download

Start with the desktop IDE

Rescriptum for Windows is available now. Experience compiler-gated deterministic verification, tree-sitter AST slicing, and local BYOK economics directly on your machine.

Download for Windows (x64)
v0.6.0 Live Release · Free Setup & PortableCloud dashboard

Native Windows 10/11 · Multi-agent swarms · Tree-sitter AST · Local SQLite BYOK