Start free

Technology

Built like infrastructure.
Because it is.

This page is for the engineer doing the evaluation: how AnyForge works, which failure modes we designed against, and where the hard guarantees live.

Orchestration

One Engineer, a graph, and a single interrupt.

Crew runs on a LangGraph state machine with Firestore-persisted checkpoints. The topology is deliberately simple: industry data on multi-agent handoff failure (41–87% in published studies) convinced us that fewer, more capable agents beat larger casts.
  • The Engineer. One long-horizon agent (up to 80 tool rounds) reads the codebase, applies patches, runs your tests, consults read-only specialists on demand, and opens the PR.
  • Parallel review. On PR open, the Architect, Security and QA specialists fan out in parallel over the unified diff.
  • One gate. hil_ship emits the approval card and calls interrupt(). The graph cannot merge without a decision.
  • Amend, then stop if nothing changed. An amend decision re-enters the Engineer on the same branch with the operator’s feedback. If an amend round produces no new commits, the graph halts loudly instead of recycling an unchanged PR through review.

Every halt has a name, with a documented recovery action:

  • engineer_no_pr
  • coverage_plateau
  • runaway_steps
  • engineer_amend_loop_exhausted

runaway_steps has a hard 3,000-round ceiling. Reliability is a taxonomy, not a vibe.

Determinism

Fuzzy editing is a bug class. We removed it.

  • apply_patch: git-native edits

    Every code edit is applied with git apply --check, then git apply. A stale or misaligned patch is rejected, never fuzzy-matched into the wrong place. Anchor and file-level rejection caps stop silent retry loops, and three consecutive rejections escalate to a senior specialist.

  • run_tests: your suite is the oracle

    The runtime auto-detects your test runner: a committed .anyforge/test-command pin wins, then package.json, pytest, Cargo, go.mod. Its output is ground truth. Coverage numbers guide scope; passing your tests is the gate.

  • Read-before-cite coverage gate

    Specialist findings must quote code the agent actually read. Long verbatim spans are checked against the bytes it read, so a reviewer cannot cite a file it never opened.

  • Untrusted-context sentinels

    Repo instructions (AGENTS.md, CLAUDE.md), BRD text and escalation summaries are injected inside sentinel wrappers and can never override enforced constraints. Prompt injection from your own artifacts is a modeled threat.

  • Headless-browser verification

    A built-in headless Chromium tool starts the dev server if needed, renders the page at desktop or mobile size, and returns a screenshot with structured console errors and failed network requests. “It compiles” is not the bar; “it renders without errors” is.

  • Isolated workspaces

    Each crew works in a fresh git worktree with your pinned setup command (10-minute cap, content-hash cached). Code Studio commands run in an in-browser WebContainer or fail over to AnyForge Cloud Agents automatically: same command, same repo, either substrate.

Code intelligence

Agents that know your codebase.

Every agent surface shares one code-intelligence layer. An indexer builds a call-and-import graph, plus vector embeddings of symbol-aligned code chunks for semantic search.
  • Parsing. TypeScript compiler API for TS and JS; tree-sitter for Go, Kotlin, Python, Java and Rust.
  • Refresh. SHA-gated and incremental: on every PR merge via webhook, on demand, and on a rolling sweep.
  • Analysis. Every pass runs god-node detection, community structure, surprising connections and doc-to-code drift.

Every call edge carries a confidence label.

  • extracted import-verified
  • inferred unique name match
  • ambiguous agents verify before acting

The same tools serve the Engineer, the PR reviewers, the Oracle, and you, in the console’s interactive cross-repo code graph:

  • search_code_semantic
  • find_callers
  • trace_path
  • graph_stats

Model layer

Provider-neutral by architecture, not by adapter cleanup.

SDK-compatible endpoints mean existing client code migrates by changing a base URL.

  • /v1/anthropic
  • /v1/openai
  • /api/v1/google
  • Routing. Live per-provider model catalogs (Anthropic, OpenAI, Gemini, OpenRouter), per-provider failure isolation, and intent routing by rules, regex or embeddings.
  • Durable streaming. An interrupted agent stream replays on reconnect instead of dying with the tab.
  • Private & custom LLM hosting

    Route to models on infrastructure you control: an Ollama daemon, a vLLM or llama.cpp cluster, or a dedicated LiteLLM gateway deployed in your VPC, on-prem, or air-gapped. The models below run as first-class agent models, with the same governance, audit and metering as any frontier cloud:

    • GLM-4.6
    • GLM-4.5 Air
    • DeepSeek V3/R1
    • Qwen
    • Llama
    • Mistral

    Open-weights traffic can route direct to the vendor, bypassing marketplace markups.

  • Claude Max OAuth routing

    Paste an sk-ant-oat-… token and agent traffic bills against your flat Claude Max subscription instead of metered API rates. A self-pacing throttle reads Anthropic’s rolling 5-hour and 7-day utilization headers (soft pace at 80%, hard block at 95%), takes the 1-hour extended prompt-cache TTL, and falls back to a metered key automatically on 429.

  • Metering that cannot drift

    One flat platform fee, computed as ceil(tokens × rate / 1M) on actual throughput: cache reads weighted down, failed calls never accrue. Budgets are checked in the execution path and warn as spend reaches them, while the runaway guards halt a looping run. The meter audits itself: a two-ledger reconciliation pulls real spend from each provider’s usage API and surfaces any leakage per model and day.

Security

The guarantees an auditor can verify.

  • Hash-chained audit ledger

    Each governance event is SHA-256 hashed over its content and the previous event’s hash, forming an append-only chain. Database rules block application clients from writing the audit collections, and altering any past event breaks every hash after it.

  • Cryptographic approval proof

    Each human approval records a SHA-256 proof binding the approver’s identity, the timestamp and the content hash: exportable evidence of who approved what, when, against which diff.

  • Guardrails in code

    The crew runtime enforces circuit breakers on runaway runs and offers each role only the tools on its list. The crew graph routes every run through its gates, so the Engineer cannot skip one. Code sets these limits, not prompt etiquette.

  • Tenant isolation

    Auth custom claims are enforced in database security rules, with a defensive cross-tenant filter on the memory layer. Repo access uses each operator’s own GitHub OAuth token, with no shared company-wide PAT, live scope preflights, and hourly credential-health probes.

  • Secrets & supply chain

    All customer credentials live in Google Cloud Secret Manager; the database stores pointers only. Dependencies with active supply-chain incidents are version-pinned, and memory and telemetry infrastructure is self-hosted: customer tokens never reach third-party analytics clouds.

  • Self-healing operations

    Background sweeps keep the fleet honest: circuit breakers on runaway crews, auto-resume for stalled runs, hourly credential-health probes with reconnect prompts, MCP OAuth token refresh, agent-question and HIL timeouts (which never auto-approve), and a 15-minute platform smoke sweep that exercises hot paths before your users do.

  • The deploy boundary

    AnyForge produces and merges PRs. It never deploys and never holds infrastructure keys. Your CI/CD reports release outcomes over signed webhooks (HMAC-SHA256), and AnyForge responds by opening hotfix work: the loop closes without AnyForge ever touching production.

Interop

An API-first platform that meets your tools where they are.

Everything the console does, the key-authenticated control API does too.
  • Control API

    Repos, crews, initiatives, programs, work items, approvals, coverage ingestion, escrow and observability signals, at /api/v1/control/*. Scoped API keys carry least-privilege grants: read, write or approve.

  • AnyForge MCP server

    Stdio via npx, or hosted Streamable HTTP, puts ~50 tools into Claude Code, Cursor or any MCP client: dispatch and amend crews, approve gates, query the Oracle, sync coverage, drive escrow.

  • Integrations marketplace

    Inbound, the MCP integrations marketplace connects Datadog, Sentry, Jira, Linear, Notion, Salesforce, Firebase, Aikido and more, with OAuth auto-refresh and operator-gated mutation tools.

  • Observability ingestion

    Alerts from seven providers are normalized into fingerprint-grouped production signals. An OTLP endpoint accepts OpenTelemetry metrics and traces.

  • Skills

    Skills follow the open agentskills.io format with progressive disclosure: lightweight metadata in the system prompt, full bodies loaded only on invocation, so a large skill library never bloats the context window.

  • Machine-readable references

    llms.txt, llms-full.txt, the RFC 9727 API catalog at /.well-known/api-catalog, and JSON-LD on every page.

Stack

The stack, layer by layer.

Each layer of the AnyForge stack and its implementation
LayerImplementation
OrchestrationLangGraph StateGraph with a Firestore-backed checkpointer: every crew is resumable, replayable and auditable at the graph-state level
AnyForge Cloud AgentsDedicated container image on Cloud Run with every major toolchain baked in (Node, Python, Go, Rust, Java/Maven/Gradle, Kotlin, .NET, Ruby, PHP) plus gcloud / aws / az / terraform CLIs
FrontendNext.js App Router (SSR), React, TypeScript, Tailwind; Code Studio uses in-browser WebContainers with cross-origin isolation, with automatic failover to AnyForge Cloud Agents
Data & authFirestore (EU region) with deny-by-default security rules, Firebase Auth (GitHub / Google / Microsoft OAuth), custom-claims tenancy
PolicyIn the crew runtime, in TypeScript: circuit breakers for runaway steps, loops and coverage plateaus, and per-role tool lists that decide which tools each agent is offered. Company governance rules are checked before each model call, and a match is recorded in the audit chain
MemoryGoverned memory store with bi-temporal versioning (Zep-based), policy-checked and fail-closed, portable across LLM providers
Model gatewayProvider adapters for Anthropic, OpenAI, Gemini, OpenRouter, Bedrock and Vertex, plus a self-hostable LiteLLM gateway for direct-to-vendor and private deployments
SecretsGoogle Cloud Secret Manager for all customer credentials; Firestore stores metadata pointers only, never values
Payments & billingStripe-backed usage invoicing with automated dunning, budget warnings in the execution path, and per-line-item fee separation
InteropModel Context Protocol servers (stdio and hosted Streamable HTTP), SDK-compatible LLM endpoints, RFC 9727 API catalog, llms.txt

Run a crew on your own repository.

Bring the model keys you already pay for, and start with one repository.