forge‑0.9 · 1M token repo context now in beta

The coding assistant your senior engineers will actually keep installed.

Forge reads your whole repo, runs your tests, and writes diffs that pass review. P50 latency 240ms. Accept rate 62%. The numbers your team will check.

Install for VS Code → See the eval

VS Code · JetBrains · Neovim · SOC2 Type 2 · no training on your code

apps/web · src/billing/subscription.ts · main

20 lines forge live

working file

 1 export async function cancelSubscription(
 2   userId: string,
 3   reason?: CancelReason,
 4 ) {
 5   // TODO: validate reason, charge proration,
 6   // downgrade plan, send confirmation
 7   const sub = await getActiveSub(userId);
 8   if (!sub) throw new SubNotFound(userId);
 9
10   // ─ cursor here ─
11 }

forge · diff suggestion tab to accept

+  const proration = await calcProration(sub);
+  if (proration.amount > 0) {
+    await stripe.invoices.createAndPay({
+      customer: sub.customerId,
+      lines: proration.lines,
+    });
+  }
+  await downgradePlan(sub, "free");
+  await mail.send("sub.canceled", { sub, reason });

reasoning trace · 480ms · 6 steps

▸considered 3 approaches 82ms

●read CancelReason, Subscription, stripe.invoices types105ms

●checked 4 recently merged PRs touching billing/* for proration patterns142ms

●re‑ran test/subscription.spec.ts in dry mode — 8 pass98ms

▸picked invoice‑then‑downgrade (matches PR #2,841 by @priya)53ms

62%

accept rate

240ms

P50 inline latency

token repo context

89%

test‑pass on suggested code

§ BENCHMARKS

Senior engineers don't care about demos. They care about these numbers.

Evaluated on SWE‑bench‑Verified, RepoEval‑Live, and 31 private monorepos contributed by partner companies. Full methodology.

Accept rate (developer kept the suggestion)

higher is better

Forge 0.9
62.4%
Cursor (sonnet)
46.8%
Copilot
23.9%
GPT‑4o raw
31.7%

Test‑pass rate on suggested patch

higher is better

Forge 0.9
88.7%
Cursor
71.4%
Copilot
50.6%
Claude 3.5 raw
63.9%

Hallucinated API / symbol calls

lower is better

Forge 0.9
1.2%
Cursor
4.1%
Copilot
8.4%
GPT‑4o raw
12.6%

Inline completion latency P50

lower is better

Forge 0.9
240ms
Cursor
320ms
Copilot
410ms
Continue.dev
780ms

Eval set forge‑eval‑v4 · 18,204 tasks · 31 partner repos · published 14 Apr 2026

§ USE CASES

It does the boring half of the job. So you can do the interesting half.

forge.complete

Inline completion

Multi‑line, type‑aware, repo‑grounded. Reads your real imports — not its guess.

if (user.role === "admin") {

+ return audit.recordAccess(user, "billing");

}

forge.refactor

Refactor suggestions

"Extract this loop into a queue worker" — across files, with imports, types, and tests updated.

− processSync(orders)

+ queue.enqueue("orders.process", orders)

+ 4 files · + 3 tests · 0 regressions

forge.tests

Test generation

Writes the cases that actually break your code — boundary, null, race, regression. Runs them locally.

cancelSubscription.spec.ts

✓ happy path

✓ already‑canceled idempotency

✓ proration > 0 charges before downgrade

forge.debug

Debug trace analysis

Paste a stack trace. Get the suspected file, the suspect lines, the fix as a diff, and 3 questions for the on‑call.

TypeError: cannot read 'id' of undefined

at OrdersService.findOne (orders.ts:88)

→ likely cause: missing await on getActiveOrder()

forge.review

PR review summaries

Posts a structured review on every PR — risks, missing tests, similar prior PRs, and the diff your reviewer should focus on.

PR #3,412 · billing/refunds

● risk: medium · idempotency missing on retry

● similar: #2,841, #2,610

forge.agent

Background agent

Hand off a ticket. Forge clones the repo, branches, writes the patch, runs CI, and opens a PR for review.

↳ LINEAR‑248 · "fix off‑by‑one in /api/usage"

→ branch forge/usage‑off‑by‑one · 1 commit

→ CI green · opened PR #3,418

§ MODEL CARD

forge‑0.9 · production

A code‑specialized model trained on a PR‑merge dataset of 9.4M real engineering commits — never on private customer code.

context window1,048,576 tokens

repo indexingsymbol graph · semantic + AST

tool usetests · type checker · git · sandbox

training data9.4M merged PRs (permissive)

latency P50 / P95240ms / 720ms

your code policynever used for training

self‑hoston Team+ · GPU req'd

complianceSOC2 Type 2 · GDPR · CCPA

§ SDK

Drop into your CI. Or your editor.

Same engine that powers the editor, exposed for headless agents, PR reviewers, and CI gates.

@forge/sdk · 0.9.4

from forge import Forge

forge = Forge(api_key="sk_live_…")

patch = forge.task(
    repo="github.com/linnea/web",
    instruction="fix off‑by‑one in /api/usage daily aggregation",
    tools=["tests", "git"],
    open_pr=True,
)

# patch is a structured diff with review notes
print(patch.url, patch.tests_passed)

import Forge from "@forge/sdk";

const forge = new Forge({ apiKey: process.env.FORGE_KEY });

const patch = await forge.task({
  repo: "github.com/linnea/web",
  instruction: "fix off-by-one in /api/usage daily aggregation",
  tools: ["tests", "git"],
  openPr: true,
});

console.log(patch.url, patch.testsPassed);

$ curl https://api.forge.dev/v1/tasks \
  -H "Authorization: Bearer $FORGE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "repo": "github.com/linnea/web",
    "instruction": "fix off-by-one in /api/usage daily aggregation",
    "tools": ["tests", "git"],
    "open_pr": true
  }'

§ PRICING

Per seat. Not per request.

Unlimited completions on Pro and Team. We absorb the inference cost — it makes for a better product and saner billing.

Free

50 completions / day · individuals only

✓ VS Code, JetBrains, Neovim plugins
✓ Single‑file context
✓ Community Discord support
— No PR review · no agent runs

Get started

Pro

most individuals

$24 / mo

unlimited completions · billed monthly

✓ Everything in Free
✓ Full repo context (up to 1M tokens)
✓ 200 agent runs / month
✓ PR review on personal repos
✓ Priority inference

Start 14‑day trial

Team

$49 / seat / mo

shared repo context · admin controls

✓ Everything in Pro
✓ Shared repo embeddings across team
✓ SSO · SCIM · audit log
✓ Self‑host on your GPUs
✓ 99.9% SLA

Contact sales

Customer story · Mercury (Series B, 84‑engineer team)

“Three months in, Forge is the only assistant our seniors haven't uninstalled. Accept rate landed at 64% on our codebase — the rest of the field hovered around the high‑20s.”

Yusuf Abara

CTO, Mercury

+42%

merged PRs / engineer / week

−18%

incidents per release

3.4h

saved per engineer per day

12 wk

to org‑wide rollout

§ COMPARISON

Forge vs the field.

capability

Forge

Cursor

Copilot

Open‑source

1M‑token full‑repo context✓200kfile‑levelDIY

Runs your tests before suggesting✓———

No training on your code (contractual)✓✓opt‑out✓

Background agent w/ PR creation✓limited—DIY

Self‑host on your GPUs✓——✓

Neovim parity with VS Code✓partialpartial✓

Per‑seat unlimited (no token meter)✓caps✓DIY

§ FAQ

Questions a staff engineer would ask.

Is my code used to train the model?+

No. Customer code is never used to train any Forge model — it's a contractual commitment in our DPA, not just a setting. Prompts and completions are retained 14 days for abuse detection only, then deleted. You can shorten retention to zero on Team+.

Does it work offline, or can I self‑host?+

Team customers can self‑host the smaller model (forge‑0.9‑mini, 240ms P50) on a single A100 or 2× L40s. The full 1M‑context model requires 4× H100 or equivalent. Editor extensions can run fully air‑gapped against your self‑hosted endpoint.

Which IDEs are supported — VS Code, JetBrains, Neovim?+

All three at feature parity (including agent runs, PR review, and the inline diff UI). Zed is in public beta. Sublime and Emacs use the LSP shim — completions and chat work; agent runs require a sidecar.

How is the context built across a large monorepo?+

Forge maintains a symbol graph (AST‑level) and a semantic index, refreshed on every commit via your CI. For an inline completion, retrieval is symbol‑graph first (callers, callees, types), semantic second (similar past PRs), with a budget capped at 1M tokens. Average retrieval latency is 38ms on a 2.4M‑file repo.

Can I plug in our private packages and internal SDKs?+

Yes. Forge auto‑indexes any registry you authenticate to (npm/pnpm, PyPI, Cargo, Go modules, internal Artifactory). For closed‑source SDKs, we index type signatures and docs only — never the implementation source.