What Forge Is

Forge is a local-first operating system for your work and life.

Forge is a local-first system for goals, projects, tasks, task runs, notes, wiki pages, calendar planning, preferences, health records, movement history, sleep, and Psyche data. This site explains the product itself: what each area is for, how the pieces fit together, and where to go when you want to plan, act, reflect, or connect Forge to your tools.

Forge keeps planning, execution, memory, health, and agent access inside one shared runtime. Start with the single-command install, then use the guide map below to go deeper into features, engineering, integrations, or the API.

React 19 + Vite 6 Fastify 5 + OpenAPI 3.1 SQLite-backed wiki OpenClaw + Hermes + Codex Iroh iPhone pairing

Get started Browse docs

Getting Started

One command installs Forge and guides the rest.

Single-command install

Start here for the browser UI, OpenClaw, Hermes, Codex, or all of them together. The guided installer sets up the local Forge runtime, discovers agent hosts in the background, and lets you keep or change the real data folder before optional iPhone pairing.

npx forge-memory

The adapter menu selects every detected host by default, shows missing hosts as disabled rows, and supports Space to toggle OpenClaw, Hermes, and Codex.

Development install

Use the same polished flow when you are working from a Forge checkout. Dev mode links adapters to this source tree and defaults to the real shared Forge data folder.

npx forge-memory --dev

Reconfigure any time

Reopen the full setup flow after install. Forge uses the current config as defaults, so changing adapters, data folders, or iOS pairing does not require starting over.

npx forge-memory configure

Operate the local runtime

Check health, open the UI, restart the runtime, or pair the iPhone companion from the same CLI instead of hunting through adapter-specific commands.

npx forge-memory status
npx forge-memory doctor
npx forge-memory ui
npx forge-memory restart
npx forge-memory stop
npx forge-memory export
npx forge-memory uninstall
npx forge-memory pair-ios

Export keeps a portable backup path close at hand. Uninstall removes the runtime manager and cache while keeping your Forge data folder unless you explicitly ask to delete it.

Advanced adapter docs

The manual OpenClaw, Hermes, and Codex commands are still documented for recovery, source-linking, and host-specific debugging. They are reference paths, not the normal quickstart.

Advanced adapters Source app

Guide Map

Once Forge is running, use the docs in the order that fits your goal.

Features

Learn what you can do in Forge across planning, knowledge, movement, sleep, health, and reflection.

How Forge is built

Understand the architecture, storage model, runtime surfaces, and technical stack.

Run it yourself

Start Forge locally, verify the main app paths, and review the contributor workflow model.

Integrations

See how Forge connects to OpenClaw, Hermes, Codex, and the iPhone companion without splitting your data into silos.

Companion transport

Keep the base install simple, then go deeper into Forge's own Iroh and QUIC pairing path, relay behavior, QR payload, stream protocol, fallback mode, and license boundary.

Agent identity

Understand why OpenClaw, Hermes, and Codex are stable agents, why reconnects are sessions, and how those agents link to human or bot users with their own Kanban ownership.

API reference

Interactive API explorer with route descriptions, typed payloads, live Try it out support, and the downloadable generated spec.

Support

Get help with pairing, sync, HealthKit, movement history, and the companion app.

Product At A Glance

These screenshots show the core Forge surfaces before you dive into the deeper docs.

Forge overview dashboard showing execution, planning, memory, and health cards. — The overview dashboard is the fastest way to understand the product: active work, linked context, health signals, and reflection all show up in one local-first runtime.

Forge Kanban board showing execution lanes and task controls. — Execution stays operational instead of decorative, with lane movement, owner scopes, and fast task actions directly in the board.

Forge wiki memory view showing linked written context and shared notes. — Notes and wiki memory stay close to execution, so context becomes part of the system instead of getting stranded in external documents.

Forge sleep overview showing the latest night summary and sleep calendar. — Health surfaces such as sleep are first-class product areas, not side widgets bolted onto a project tracker.

iPhone Companion

Forge Companion for iPhone is currently in beta.

TestFlight Beta Health, movement, and sync

Forge Companion is the native iPhone bridge for Forge. It pairs with your Forge runtime, imports HealthKit sleep and workouts, captures passive movement history, and gives you a native life timeline plus diagnostics while Forge itself stays local-first.

The app is currently in beta through TestFlight while the sync, movement repair, and timeline systems are being tightened in real-world usage.

Forge Companion pairing and discovery screen in portrait. — Pairing and runtime discovery

Forge Companion paired home screen in portrait. — Paired home and sync controls

Forge Companion life timeline screen in portrait. — Life Timeline with stays and moves

Forge Companion diagnostics screen in portrait. — Diagnostics, payloads, and logs

Current Stack

The product runs on a modern local-first web and sync stack.

Layer	Current stack	Notes
Web UI	React 19, TypeScript 5.8, Vite 6, Tailwind CSS 4	Served under `/forge/` in production and local dev.
Backend	Fastify 5, TypeScript, OpenAPI 3.1	Spec is generated from `server/src/openapi.ts`.
Storage	SQLite-backed wiki memory	Forge keeps canonical runtime records locally first.
Desktop / native	Tauri 2, Swift iOS companion, Rust Iroh bridge	Desktop shell plus HealthKit-powered iPhone companion with default Iroh pairing.
Docs	GitHub Pages static site + rendered OpenAPI reference	The Pages artifact includes this site and the generated spec.

Where Things Live

These are the main entry points for the app, API, and docs.

Local development

UI:  http://127.0.0.1:3027/forge/
API: http://127.0.0.1:4317/api/v1/
Spec: http://127.0.0.1:4317/api/v1/openapi.json

GitHub Pages

Docs home: /forge/
Engineering: /forge/engineering.html
Development: /forge/development.html
Integrations: /forge/integrations.html
API docs: /forge/api/

Forge overview dashboard — Forge keeps execution, planning, memory, health, and Psyche records in one runtime. Use the UI when the work is visual; use the API or agent adapters when the work is operational.

Core Product Areas

These screenshots show how Forge turns planning and reflection into daily practice.

Forge Kanban board showing task lanes and execution controls. — Kanban is the flagship execution board, with lane movement, filters, owner scopes, and direct task actions.

Forge hierarchy view showing the goal-to-subtask tree, shared filters, and operational progress. — The hierarchy view keeps the whole planning ladder visible at once, so goals, projects, issues, tasks, and subtasks stay legible without flattening them into one lane list.

Forge Movement page showing the life timeline with stays and trips. — Movement turns passive place and trip history into a life timeline with stays, places, corrections, and linked context.