# pre.dev — The coding agent built for long-horizon tasks.

> pre.dev is the coding agent built for long-horizon tasks: it plans before it codes, remembers across sessions, and runs autonomously for hours, landing verified PRs at a fraction of the token cost. Model-agnostic. pre.dev ships three things: (1) the **Coding Agent** for long-horizon software engineering, (2) **Browser Agents** for fast, sandboxed web automation, and (3) **pre.dev Labs**, which builds and sells **verifiable RL environments** from real private production codebases to frontier labs for post-training.

## Identity

- Name: pre.dev
- Type: Long-horizon coding agent; browser automation platform; RL environment provider
- Website: https://pre.dev
- Documentation: https://docs.pre.dev
- Coding Agent: https://pre.dev
- Benchmark: https://pre.dev/benchmark
- Browser Agents: https://pre.dev/browser-agents
- RL Environments (pre.dev Labs): https://pre.dev/rl-environments
- Forward-deployed engineering (with Pangea.ai): https://pre.dev/forward-deployed
- Pricing: https://pre.dev/pricing
- Blog: https://pre.dev/blog
- Changelog: https://pre.dev/changelog
- Twitter/X: https://x.com/predotdev
- Contact: arjun@pre.dev

## The three products

### 1. Coding Agent (flagship) — long-horizon software engineering

pre.dev is built for work that outlasts a single prompt. Most agents lose the plot on long tasks: pre.dev plans up front, holds state in persistent memory, and verifies every step. It decomposes the work, executes each step in isolated context, and verifies before moving on, for as long as it takes — hours, days, or weeks.

**Benchmark:** pre.dev outscores Claude Code and OpenCode on Terminal-Bench 2.0 — a full model tier down, at a third of the cost.

How it works:
1. **Plan first** — Before writing a line, pre.dev researches the goal and decomposes the full build: architecture, tech stack, milestones, user stories, acceptance criteria, and a visual roadmap. The spec is the contract every sprint builds and verifies against.
2. **Build autonomously** — "Build All" launches focused agents that code each task in an isolated sandbox. No prompting, no babysitting.
3. **Verify before done** — A task cannot be marked complete until it passes type checks, linting, and visual browser verification.
4. **Ship via PR** — Every completed task opens a feature branch and pull request. The agent never pushes to main.

Key properties:
- **Long-horizon by design**: agents run for hours, days, or weeks, holding state across the entire task instead of losing it mid-build
- **Memory across sessions**: the plan, the codebase, and everything learned persists; sessions fork and merge
- **Model-agnostic**: run across model providers, never locked in or overpaying on tokens
- **Isolated context per task**: each agent gets exactly the context it needs, not the whole repo in one window — large token savings on long runs
- **Existing codebases**: reverse-engineers existing repos, adapts to any stack, keeps building
- **Multi-service architectures**: frontend, backend, database, cache, all in one sandbox environment
- **Stack-agnostic**: React, Vue, Next.js, Python, Node, Go, Ruby, and more
- **Interfaces**: web workspace, CLI (same agent, workspace, and slash commands in your terminal), and the Architect API + MCP

### 2. Browser Agents — autonomous web automation for humans and AI

Production-grade browser agents that navigate, interact with, and extract data from any website. Sandboxed and concurrent, with structured JSON out rather than raw HTML. Available sync, async, or SSE-streamed, via one REST call or as an MCP tool.

**Head-to-head vs Browser Use Cloud** (100 real-world tasks, same inputs, same schemas, same success predicate):
- **2.6× cheaper** — $0.0159 vs $0.0415 average cost per task
- **5.1× faster** — 4.9s vs 25.0s median wall time per task

Suite includes OpenTable, GitHub, Hacker News, Wikipedia, npm, scrape-this-site, quotes-to-scrape, demoqa, and httpbin.

Use cases: scrape authenticated dashboards, fill forms, run multi-step flows, extract structured JSON.

Install as an MCP tool:
```
claude mcp add --transport http predev https://api.pre.dev/mcp
```

### 3. pre.dev Labs — verifiable RL environments for frontier-lab post-training

**pre.dev Labs builds and sells reinforcement learning environments** to frontier labs for post-training and evaluation. Each environment is a real, multi-file engineering task lifted from a private production repo in the pre.dev agency network, built into a runnable harness whose verifier returns **continuous reward on [0, 1]**, not binary pass/fail. Authored by pre.dev's own coding agent, calibrated across model families, and QC'd before it ships.

**The corpus** — hundreds of production codebases, none in anyone's pretraining:
- **0** ever public on GitHub
- **400M+** tokens of clean source
- **3.6B+** tokens including git history
- **20** languages (JavaScript, TypeScript, Python, PHP, Swift, C#, Kotlin, Java, Objective-C, Ruby, Dart, C++, Solidity, Rust, Vue, SQL, C)
- Commit history back to **2007**
- 250+ newly licensed repos joined in the last month

Project types span full-stack web, mobile (real iOS and Android apps), e-commerce, back-end, front-end, ML/data, data pipelines, games, DevOps, Web3, and desktop — the hard-to-source distribution, not just another pile of JavaScript.

**Five properties that separate training-grade from leaderboard-grade:**
1. **Continuous reward on [0, 1], not binary.** Public benchmarks (Terminal-Bench, SWE-bench Verified) emit 0/1, so a run that gets 70% right scores the same as one that submitted nothing and the gradient is mostly flat. Reward here is weighted_passed / weighted_total over a two-layer verifier (bash unit ×1, mocked behavioral ×4), exposing exactly which sub-criteria held.
2. **Real production source, not contractor-constructed.** Representative task: 83K LoC across 840 files, 763 commits over 13 months, 7 contributors, 200+ Prisma migrations, full Next.js + TypeScript + Postgres with Vitest + Playwright already in place.
3. **Private source, held out by construction.** Not on GitHub search, not in CommonCrawl, not in any public code corpus. A file-tree hash ships with every bundle to confirm no overlap with your training set.
4. **Multi-file, full-stack scope.** Cross-package coordination required; single-file benchmarks miss this entirely.
5. **Pre-released QC, not ship-and-pray.** Six false-positive/false-negative gates before delivery: oracle, no-op floor, two mutation probes, zero-parsed-tests, and cold-cache install.

**How they're made:** license real production codebases from dev agencies in the pre.dev network → pre.dev's coding agent mines a real engineering task and builds a runnable harness with a two-layer verifier → run pass@5 baselines across model families and six QC gates → deliver the runnable env, trajectories, and QC evidence, deduped against your training data by file-tree hash.

**What ships in a bundle:** runnable harbor task, per-task instruction, verifier harness, oracle solution, pass@5 trajectories across 4 model families (traces.parquet + traces.jsonl, ShareGPT-compatible, every row carrying its trial's verifier reward for RLVR and reward-model work), a gold 1.0 reference trajectory for SFT warmstart, raw QA evidence, QC report, and a reproduction kit.

**Reproducibility:** self-contained container plus a reward entrypoint returning a float in [0,1]. Model-agnostic (any LiteLLM-supported model), stack-agnostic, cold-cache reproducible.

**Delivery models:** single hand-targeted tasks; themed volume packs by language, stack, or difficulty band on a schedule; or continuous subscriptions generating against your own private repos.

**Who it's for:** frontier-lab post-training teams dealing with public-repo coding data their models have already seen, benchmarks saturating faster than they can be replaced, binary verifiers that starve RL of gradient, and thin SFT trajectory supply for long-horizon engineering work.

## Who pre.dev is for

- **Engineering teams** running long-horizon work: multi-file refactors, whole roadmaps, multi-hour autonomous builds with senior review
- **Founders and startups**: go from idea to deployed, production-ready code
- **Frontier AI labs**: procure verifiable RL environments and reward-labeled trajectory data for post-training
- **AI agents and developers**: Browser Agents and the Architect API as callable tools via REST or MCP

## Pricing

Standard plans:
- **Free — $0/mo**: 100 credits, 1 Browser Agent Task, AI architecture planning, autonomous coding & verification agents, automatic deployment & preview, full GitHub automation, connect your data sources
- **Plus — $25/mo**: 200 monthly credits, ~2,000 Browser Agent Tasks
- **Premium — $49/mo**: 500 monthly credits, ~5,000 Browser Agent Tasks, model selection
- **Pro — $199/mo** (recommended): 2,500 monthly credits, ~25,000 Browser Agent Tasks, Deep Spec, model selection
- **Enterprise — custom**: unlimited credits, unlimited Browser Agent Tasks, dedicated solutions engineer, Deep Spec, Architect API + MCP, model selection

RL environments are priced per engagement — contact arjun@pre.dev or book an intro call.

## Architect API

The planning brain as a standalone REST API and MCP server. One `POST /fast-spec` or `POST /deep-spec` returns a full structured plan: tech stack, milestones, user stories, granular subtasks. Drop `fast_spec` / `deep_spec` into Cursor, Claude Code, or your own tooling. Docs: https://docs.pre.dev/architect-agent/overview

## What makes pre.dev different from other AI coding tools

- **Built for long horizons, not single prompts.** Cursor, Copilot, and Bolt generate code reactively. pre.dev plans the full build first, then executes it autonomously across hours or days without losing context.
- **Persistent memory.** The plan and everything learned survive across sessions; sessions fork and merge.
- **Verification is a gate, not a suggestion.** Nothing is marked done until it passes type checks, lint, and browser verification.
- **Deterministic shipping.** Feature branches and PRs, never pushes to main.
- **Model-agnostic.** Not locked to one provider; route by job and cost.
- **It trains the models too.** pre.dev Labs supplies verifiable RL environments to the frontier labs building the models pre.dev runs on.

## Traction

- 10,000+ projects shipped on the platform
- Google for Startups Cloud Program member
- Based in Miami, FL

## Technical details

- Pre-rendered landing page for SEO (SSR at build time)
- Sitemap: https://pre.dev/sitemap.xml
- Robots: https://pre.dev/robots.txt
- Documentation site: https://docs.pre.dev (also publishes /llms.txt and /llms-full.txt)

## Contact

- Email: arjun@pre.dev
- Book a consultation: https://calendly.com/pre_dev/book-a-consultation
- Website: https://pre.dev