Private beta — join the waitlist

Your codebase is
too big for any
context window.
So we killed the
context window.

Hotcopy is a managed recursive AI coding CLI. Agent swarms decompose impossible problems in parallel. No context limits. No API keys. No config. Just install and go.

$ npx hotcopy login
▸ Opening browser... authenticated via GitHub.
$ hotcopy "refactor auth to use OAuth2 with PKCE"
▸ Scanning project... 2,847 files indexed
▸ Orchestrator dispatching to 12 agents...
▸ [agent-1] analyzing auth flow  [agent-2] mapping dependencies
▸ [agent-3] generating tests   [agent-4] security audit
▸ Hot copy. 14 files modified. All tests passing.
Context depth
50+Parallel agents
5xCheaper than Opus
0API keys needed
How it works

Recursive Language Model architecture

A root orchestrator decomposes your task. Worker agents execute in parallel. Results synthesize back. No single model sees everything — but everything gets seen.

01

Install and authenticate

One npx command. Log in with GitHub. We handle the models, orchestration, scaling, and routing. No API keys, no cloud accounts, no YAML files.

02

Agents swarm your codebase

The orchestrator builds a plan and dispatches worker agents across your project. Each gets targeted context — relevant files, repo map, task scope. They work simultaneously.

03

Results synthesize back

The orchestrator collects outputs, validates consistency, and applies changes. If something's off, it recurses — dispatching corrective agents until the task is clean.

Architecture

Fully managed. You just write code.

We run the models, orchestration, routing, and scaling on hardened infrastructure. Your source stays local. Only targeted context reaches agents in encrypted, ephemeral channels. Code is never stored or trained on. Decisions and patterns persist in your private memory vault.

Your machine
HOTCOPY.md
MCP servers
Test suite
◀ contextagents ▶
RLM Engine Managed cloud
◀ resultsrecurse ▶
Agent swarms
Intelligent routing
Load balancing
Auto-scaling
Features

Built for the codebase nobody
fully understands anymore

Not the 50-file demo project. The 2-million-line monorepo with legacy PHP mixed with modern TypeScript.

▸ swarm

Parallel agent swarms

10, 20, 50+ worker agents analyzing different parts of your codebase simultaneously. Security audit, test generation, and docs — happening in parallel. Wall-clock time drops 5-10x.

▸ import

One command to migrate

hotcopy import --from claude-code brings your CLAUDE.md, MCP servers, permissions, and hooks. Same for Gemini CLI users. Your existing setup transfers in seconds.

▸ zero-config

No API keys. No cloud setup.

Authenticate with GitHub and go. We manage the models, routing, scaling, and infrastructure. You manage your code. That's the deal.

▸ secure

Scoped. Ephemeral. Never stored.

Only the files relevant to each task are sent to agents in scoped, encrypted chunks. Source code is never persisted or trained on. Only agent memories — decisions, patterns, and failure records — persist to make future sessions smarter.

▸ pricing

Predictable pricing

Generous included tasks on every plan. No per-token billing, no counting input vs output, no surprise invoices. Overage is transparent and billed at the same rate. Ship code, not spreadsheets.

▸ ctx

Recursive context decomposition

No agent sees your whole codebase. Each gets surgically targeted context — relevant files, dependency maps, task scope. The system sees everything through decomposition.

Blackbox memory engine

Your agents remember everything.
Across sessions. Across machines. Across teams.

Other coding tools forget everything when the session ends. Hotcopy's Blackbox memory engine gives your agents persistent intelligence that compounds over time.

memory

Semantic memory search

Agents search past decisions, failures, and patterns using vector similarity. Before attempting any approach, they check what's been tried before.

learning

Failure analysis

Every failed approach is categorized and stored. Agents query past failures before attempting fixes — they never repeat the same mistake twice.

planning

DAG-based task planning

Complex tasks decompose into dependency-validated execution plans with parallel execution, cycle detection, and heartbeat tracking.

continuity

Session handoffs

Stop work on your laptop, pick it up on your desktop. Cross-machine transfer tokens carry full session context — nothing is lost.

safety

Anti-pattern detection

Detects when agents are looping, yak-shaving, or going off-track. Convergence tracking breaks unproductive cycles before they burn tokens.

team

Shared team memory

When one developer's agents discover a rate limit gotcha or API quirk, every team member's agents know it immediately. Knowledge compounds across the org.

Memory that compounds. Agents that learn. Join the beta.

Pricing

Simple plans. Predictable bills. No metering anxiety.

Every paid plan includes tasks at a discount. Need more? Overage is $1.30/task — still 5x cheaper than the competition.

Recon
$0
forever
Kick the tires. See what recursive agent swarms can do on your real codebase.
  • 10 tasks / month
  • Up to 3 parallel agents
  • Standard routing
  • Community support
  • CLI access
Join waitlist
Commander
$199
/ seat / month
For teams running full-scale operations. $650 in included tasks per seat — the more you use, the more you save.
  • 500 tasks included / seat / month
  • Up to 50+ parallel agents
  • Dedicated model capacity
  • Blackbox team shared memory
  • SSO & audit logs
  • SLA & priority support
  • Custom routing rules
  • Volume discounts on overage
Join waitlist
Real numbers

Same task. 5x cheaper.

We ran a real security audit — 52 files, 82 parallel scouts, 15 orchestrator turns. Here's what you'd pay.

The task
Full security audit of a 52-file codebase. 15 orchestrator turns. 82 parallel scout agents analyzing files for vulnerabilities, generating fixes, and validating results.
Total input tokens~310K
Total output tokens~205K
Files analyzed52
Parallel agents dispatched82
Hotcopy
$1.30
Orchestrator: $0.40
Scout agents: $0.90
82 agents in parallel
vs
Opus 4.6
$6.68
Input: $1.55
Output: $5.13
Sequential tool calls only
5x cheaper. Massively faster.
Parallel agents finish in minutes. Sequential tool calls take an hour.
Even with Opus cache hits (~$2-3), Hotcopy still comes in cheaper.
Compare

What Hotcopy does that others can't

Parallel agents and MCP are table stakes. Here's where Hotcopy actually pulls ahead.

CapabilityHotcopyClaude CodeCursor
Recursive decomposition✓ RLM engine
Context rot✓ Eliminated — scoped chunks✓ 1M window, degrades✓ 200K, degrades
Persistent memory✓ Blackbox engine✓ File-based only
Learns from failures✓ Checks before retrying
Team shared memory✓ Cross-org
52-file security audit$1.30~$6.68 (Opus)Varies (opaque)
Predictable pricing✓ Included + overageOpaque caps$200-$1,800+/mo
Import config✓ One command
Parallel agents✓ 50+ scouts✓ Subagents✓ Up to 20
MCP support

Roger that.
Let's deploy.

Private beta is filling up. Drop your email to get early access.

✓ You're on the list. We'll be in touch.

No spam. Just an invite when it's your turn.