Strategic coherence for teams that build

AI coding agents are great at execution and bad at knowing why. Forge is the queryable home for your strategic intent, so any agent can pull the full picture in one call, from the tools it already uses.

Built for people shipping with agents today

Forge is in early access, for founders and engineering teams already building with AI agents and losing context, tokens, and sprints to drift.

You are building solo, with agents doing the work.

Every wasted token is your money. Every wrong sprint is time you can't get back. Forge gives your agents the context they are missing, so they stop reloading from scratch and start building in the right direction.

  • Using Cursor, Claude Code, or Codex as your primary workflow
  • Re-pasting the same context into agent sessions
  • Shipping fast, but not always sure it's the right direction

Your agents ship fast. Do they ship the right thing?

Teams whose agents write a real share of the code use Forge to connect intent to workflow over MCP, and check alignment at merge time with the GitHub app. The loop closes before drift ships, not at the quarterly review.

  • 10+ agent PRs a day across the team
  • Strategy shifts that never reach the agent sessions
  • PRs that are correct code but the wrong direction

The gap between deciding and shipping

This is where good teams quietly go wrong: the gap between what a company decided to do and what it actually ships.

The cascade breaks

Strategy and execution drift apart quietly. By the time anyone notices, a quarter of the work no longer matches what the company actually decided to do.

AI ships the wrong thing, fast

An agent with no spec confidently builds what it guessed you meant. You get 10 to 30 PRs a day, and the ones pointed the wrong way look just as clean as the right ones.

No tool owns the gap

Linear tracks tickets. Notion holds docs. Nothing connects the mission to the ticket, so nothing notices when they drift apart.

Four levels, each informing the next

Changes at the top cascade down into design and delivery, and every artifact traces back up.

01 · Orient

Set the foundations: Mission, Vision, Domain Model. Everything downstream traces back here.

MissionVisionDomain Model

02 · Directional

Set direction: the bets you are making and the outcomes that tell you they worked.

StrategyGoalsValue Proposition

03 · Structural

Design the solution: who you serve, the problems you solve, and how work flows.

PersonasProblemsWorkflowsWireframes

04 · Execution

Build with the full chain in context. Every ticket knows the goal, story, and strategy behind it.

ProjectsEpicsStoriesTickets

Catch it when it breaks

The chain is only half of it. Forge watches your code against that chain, down to the symbol, and flags what drifts before it merges, right on the pull request.

Drift, surfaced as a question

Forge re-derives the chain on every write and flags work that no longer matches it: a contract that drifted from the strategy it implements, an orphaned symbol, a stale doc-comment. You decide what matters.

Drift signals

execution · structural
6d open

Signature changed. Its doc-comment and the strategy it implements no longer agree.

Symbol:match_symbols() Strategy:Connect every artifact from mission to sprint ticket

The verdict, where you review

Every check lands as a sticky comment on the PR: which artifacts the change serves, whether the diff matches their intent, and per-criterion coverage. Your reviewers see the why, inline.

agent-helen bot commented just now

🟢 Aligned with 1 artifact

No open drift signals on the linked artifact.

Linked artifacts

  • ticket Generate embedding for public code symbols

Code review hint (AI judgment on diff vs intent)

  • ✅ matches — ticket Generate embedding for public code symbols: The diff embeds each symbol's signature and doc-comment as separate vectors and skips the gateway when the interface hash is unchanged — exactly what the ticket asked for.
Acceptance criteria coverage — 4 criteria (AI per-criterion grade)
  • ✅ met — Embeds signature and doc as separate 1536-dim vectors: writes embedding_signature and embedding_doc.
  • ✅ met — Interface-hash idempotency: an unchanged signature/doc hash skips the embed gateway.
  • ✅ met — Fail-soft: a null embedding still persists the row for later backfill.
  • 🟡 unclear — svelte-check 0 errors: not verifiable from the diff alone.

Drift re-checked on push — no new signals.

29 ways work drifts from intent

Forge ships a growing catalog of strategic-coherence checks — from plain graph rules to AI judgment and embedding geometry. Each one is grounded in organizational and strategy-execution research, and surfaces as a question you can reconcile.

Structural

13 checks

Pure rules over the graph — owners, links, priorities, lifecycle fields.

  • Stale Premise

    Active work still builds on a parent that was abandoned, made obsolete, or marked a duplicate — a live effort resting on a discontinued foundation.

  • Coordination Collision

    Two active items under the same parent are being worked by different people at the same time, risking duplicated effort or a clash.

  • Lifecycle Contradiction

    An item's status fields disagree with each other — closed with no reason, a closure reason on something still open, or a priority where one doesn't belong.

  • Duplicate Singleton

    More than one live instance of something that should exist only once — like two missions, visions, or strategies — competing to be the source of truth.

  • Priority Inversion

    A child item is ranked more urgent than the parent it serves — high-priority work hanging off something that's been deprioritized.

  • Owner Over-Allocation

    One person owns more in-flight work than they can reasonably move at once — a context-switching and throughput risk.

  • Coverage Gap

    Something the workspace says matters — a persona or problem — has no live work underneath it. The stated intent isn't being addressed.

  • Unowned Work In Flight

    Work that is actively in progress or in review has no owner — something is moving with nobody accountable for it.

  • No Prime Goal

    The workspace has several top-level objectives with no shared apex above them, so the work below them can ladder up to competing directions.

  • Decomposition Gap

    A mission, vision, strategy, or goal whose entire subtree never reaches doable work — intent that was stated but never broken down.

  • Priority Vacuum

    Work that's actively in flight has no priority set, so it can't be ranked against everything else competing for the same capacity.

  • Missing Accountable Owner

    A committed strategy, goal, or bet has no owner — a directional commitment with nobody accountable for whether it lands.

  • Resource Misallocation

    An objective carries urgent work underneath it that nobody is staffed on — a high-priority outcome that's effectively understaffed.

Recency

3 checks

Time-aware: staleness, review cadence, plans frozen against churn.

  • Zombie Project

    An active project whose work is all finished and that hasn't been touched in a long time — consuming attention with no live momentum.

  • Review Cadence Breach

    A committed item hasn't been reviewed within the cadence expected for its type — a mental model that may have quietly gone out of date.

  • Plan-of-Record Staleness

    A strategy or goal whose own description has gone stale while the work beneath it keeps changing — the plan frozen against what's actually happening.

Semantic

4 checks

An AI reviewer judges a pair of items — contradiction or duplication.

  • Semantic Contradiction

    Two related items pull in logically opposite directions — an AI reviewer judged their intents to be in conflict, not just differently worded.

  • Redundant Overlap

    Two items in different parts of the graph say nearly the same thing — the same intent stated twice, eroding a single source of truth.

  • Chain Contradiction

    A child's intent opposes the parent it descends from — strategic drift along the line from objective to execution.

  • Copy-Paste Cascade

    A child simply restates its parent rather than breaking it into real work — an objective copied down the chain instead of decomposed.

Vector

2 checks

Embedding geometry flags alignment outliers across the graph.

  • Root Alignment Outlier

    A piece of execution work sits among the least connected, by meaning, to the strategic root it rolls up to — barely tied to why it exists.

  • Horizontal Incoherence

    An objective's children scatter in meaning rather than cohering as one decomposition — vertically aligned but pulling apart sideways.

Property

2 checks

An AI reviewer judges a single item against its surrounding context.

  • Presupposed Capability

    A plan assumes a capability the workspace has no artifact for — the work presupposes something that doesn't yet exist.

  • Orphaned Metric

    A goal states a measurable target that none of its work actually moves — a metric nobody is working toward.

Portfolio

1 check

A workspace-wide aggregate signal, not a single-item conflict.

  • Priority Inflation

    Too large a share of items are marked high or critical, so priority stops distinguishing what actually matters most.

Your agents, with the full picture

Forge exposes your whole artifact graph over MCP. An agent loads the full context for a ticket in about two calls instead of fifteen file reads, then writes code that actually serves the goal.

https://hf.dev/api/mcp/w/{workspace-id} 29 tools
  • workspace_summary
  • artifacts_list
  • activity_feed_list
  • artifacts_create_batch
  • artifacts_delete
  • links_list
  • focus_set
  • pending_actions_list
  • code_search
  • external_references_list
  • artifact_types
  • artifacts_search
  • members_list
  • artifacts_update
  • links_add
  • links_remove
  • pending_actions_create
  • workspace_audit
  • signals_list
  • send_feedback
  • artifacts_get
  • chain_get
  • artifacts_create
  • artifacts_update_batch
  • links_add_batch
  • ready_to_work
  • pending_actions_decide
  • artifacts_devils_advocate
  • reconcile

Plugs into the tools you already use

Forge speaks MCP and ships first-party connectors, so your agents and your team reach the same artifact graph from wherever they already work.

  • GitHub
  • Anthropic
  • Linear
  • Notion
  • Figma
  • Slack
  • Discord
  • Vercel
  • Sentry
  • Any MCP client

An editor for your thinking, not your prose

Helen is the AI built into Forge. She doesn't improve your writing, she interrogates your reasoning.

  • She asks questions instead of handing you answers. She is there to interrogate your thinking, not fix your grammar.

  • She reads the whole graph, so she catches when one artifact quietly contradicts another.

  • Every comment she leaves is logged, so the reasoning behind a decision outlives the decision.

Free to use. Rough around the edges.

Forge is invite-only early access. It's free, it's rough, and your feedback shapes what ships next. Drop your email and we'll set up your workspace and send you a link.

Or email hello@helensfoundry.com directly.

Free
No cost, no trial, no credit card.
Rough
Real value, but expect rough edges.
Yours
Your feedback shapes what ships next.