forge docs

Forge SDK Overview

Use Forge to build accountable agents across six languages with one runtime contract.

Forge SDK Overview

Forge is the OpenAgent runtime and SDK surface for building agents across:

  • Rust
  • TypeScript
  • Go
  • Python
  • Swift
  • Kotlin

Forge combines:

  • provider-agnostic model access
  • tool execution and agent workflows
  • identity binding
  • capability-aware authorization
  • multi-agent collaboration primitives
  • conformance and release-gate discipline

What Forge owns

Forge owns runtime behavior.

That includes:

  • provider selection and execution
  • tool loops and workflows
  • agent identity binding
  • authority-aware execution
  • multi-agent coordination surfaces
  • public runtime contracts across six SDKs

Forge does not redefine canonical identity grammar or trust-root semantics when those belong to OAS, OAS DIDs, HMR, ENR, MHR, Aegis, or Arsenal. It links to those sections and applies them at runtime.

Current program status

Forge is being pushed to a single high-trust production bar across all six SDKs and all release-blocking downstreams.

The new coding-provider and glyph surfaces are approved as core Forge capabilities. Their contract is documented here, and their runtime implementation is part of the active production program.

Wave 2 — Rust reference implementation complete (2026-03-13)

The following capabilities are now implemented in the Rust reference SDK only:

  • Multi-model topology — agents can bind multiple models and route requests by domain, task mode, and execution topology (forge-core/topology.rs, forge-core/routing.rs).
  • Brew system — composable execution graphs with dynamic-to-frozen resolution via ResolvedBrewPlan (forge-core/brew.rs, forge-core/brew_builder.rs, forge-core/brew_resolver.rs).
  • Native web substrate — built-in web fetch, HTML parsing, markdown extraction, structured content extraction, and site compaction as runtime-level capabilities (forge-web crate).
  • Forge-Flowers bridge — bridge contract between Forge agent logic and Flowers durable execution, including WorkflowHandler implementations and ResolvedBrewPlan-to-Flowers mapping (forge-flowers crate).
  • Local identity / no-login development — lightweight development-mode identity with local users, orgs, agents, and DIDs that is clearly non-production (forge-identity/local_dev/, forge-auth/local_capability.rs).

These are Rust-first. The TypeScript, Go, Python, Swift, and Kotlin SDKs do not yet expose these surfaces. Cross-SDK parity for Wave 2 items is follow-on work.

Wave 3 — Glyph implementation and UI scaffolds (2026-03-14)

  • Glyph system — deterministic identity-derived visual rendering with payload encoding, palette derivation, SVG and terminal renderers, and 3 conformance vectors (forge-identity/src/glyph/, 194 tests).
  • Brew Studio scaffold — React 19 + TypeScript + Vite standalone app with types matching Rust Brew/topology structs, Flowers HTTP client, and microfrontend embedding contract (brew-studio/).
  • Flowers Console scaffold — React 19 + TypeScript + Vite standalone app with types matching Flowers runtime, same HTTP client contract, and embedding contract (flowers-console/).

These are scaffolds with placeholder pages, not finished products. The UI surfaces consume the Wave 2 runtime contracts — they do not invent new ones. Aut0 microfrontend embedding remains approved but not yet wired.

How to read the Forge docs

  • Overview explains what Forge is and what it owns.
  • Quickstarts routes you to the right SDK and workflow.
  • Provider Contract defines the shared runtime contract for external coding platforms.
  • Coding Subscriptions explains why those platforms are part of core Forge behavior.
  • Provider Capability Matrix explains what is universal and what is provider-specific.
  • Glyphs documents identity-derived visual rendering.
  • Security Model explains how boundary contracts, Aegis, and Arsenal constrain runtime behavior.
  • Error Catalog explains stable failure categories.
  • Migrations explains how downstreams adopt contract changes.

Use this section for

  • language-specific onboarding
  • provider and capability negotiation concepts
  • coding-subscription design and rollout status
  • glyph usage and identity-rendering concepts
  • security and migration guidance

Key rule

If a Forge page makes a concrete runtime claim, that claim should be supportable by the Forge release gate. Public docs are not allowed to outrun shipped behavior.