The strategic intent layer for AI agents

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

Built for Seed–Series B software companies with 5–100 engineers shipping 10+ agent PRs a day. Helen’s Foundry gives every agent the live strategic picture - and checks each PR against that intent before it merges.

Who it’s for

Built for agent-heavy software companies

Helen’s Foundry is in early access for Seed–Series B software companies with 5–100 engineers shipping 10+ agent PRs a day.

Seed–Series B software companies

Your 5–100 engineers ship with agents every day.

Your agents produce enough code that context and review no longer travel at the same speed. Helen’s Foundry connects each task and PR to the current decisions above it, so the team catches drift before it compounds.

  • 10+ agent PRs a day across the engineering team
  • Claude, Codex, Cursor, or another MCP-capable workflow
  • Strategy and product decisions that change faster than implementation context

CTOs & VPs of Engineering

Agent throughput has become an executive control problem.

Helen’s Foundry lets the engineering leader increase agent throughput without making senior reviewers reconstruct the premise behind every change. The GitHub check shows whether the work serves a ratified decision, not only whether the code passes.

  • Senior review load rising with agent-generated code volume
  • Rework caused by stale, duplicated, or unsupported premises
  • AI spend growing without a defensible measure of aligned output

The problem

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. Retrieval hands agents search results, not intent — and spec tools stop at the feature. Nothing connects the mission to the ticket, so nothing notices when they drift apart.

How it works

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 strategic choices 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.

PersonasProblemsArchitecture

04 · Execution

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

ProjectsRequirementsStoriesTickets

What you get

Catch it when it breaks

The chain is only half of it. Helen’s Foundry watches your work against that chain, from strategy down to the symbol, and flags what drifts before it merges, right on the pull request.

01 · On every write

Drift, surfaced as a question

Helen’s Foundry re-derives the chain on every write and flags work that no longer coheres: a goal that contradicts the strategy above it, an objective with nothing built beneath it, a plan frozen while its work churns. You decide what matters.

Contradicts a related artifact Majorseverity
6d ago
Severity: major.
Helen

Helen:This strategy commits to enterprise-only, while the goal beneath it targets self-serve growth. The two pull in opposite directions. (82% confidence)

02 · On the pull request

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.

Coherence checks

31 ways work drifts from intent

Helen’s Foundry 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.

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.

  • Stranded By Closure

    Open work left under a parent that already finished — every parent above it closed as completed or migrated, so the item needs a close, a new home, or an explicit carry-forward.

  • 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

    An active persona or problem has no live project, requirement, story, or descendant execution connected through SERVES or ADDRESSES.

  • Execution Context Gap

    Live stories that share a project or requirement declaration point cannot be traced to both an active persona and an active problem. The detector groups the repair at that declaration point while retaining exact per-story evidence; infrastructure-only tickets remain exempt.

  • 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 or goal 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.

Built for AI agents

Your agents, with the full picture

Start onboarding in Claude, Codex, or another MCP client. Ask it to use the repository, issues, PR history, existing documents, and working-session context it can already access to draft the initial intent graph through Helen's MCP tools. Your team ratifies the material decisions; every connected agent then loads the live context for its work instead of reconstructing it.

https://hf.dev/api/mcp/w/{workspace-id} 40 tools
  • workspace_summary
  • artifacts_list
  • demand_context_get
  • members_list
  • artifacts_update
  • links_add
  • links_remove_batch
  • work_packet
  • pending_actions_decide
  • artifacts_suggest_parents
  • signals_list
  • reconcile
  • workspace_external_reference_get
  • docs_list
  • artifact_types
  • artifacts_search
  • links_list
  • artifacts_create
  • artifacts_update_batch
  • links_add_batch
  • artifacts_set_parent
  • context_update_proposals_create
  • pending_actions_list
  • code_search
  • signals_rate
  • external_references_list
  • send_feedback
  • artifacts_get
  • chain_get
  • activity_feed_list
  • artifacts_create_batch
  • artifacts_delete
  • links_remove
  • ready_to_work
  • pending_actions_create
  • workspace_audit
  • code_for_artifact
  • signals_rate_batch
  • workspace_external_references_list
  • docs_get

Shipping with Claude Code? Connecting is one command:

claude mcp add --transport http helens-foundry https://hf.dev/api/mcp/w/{workspace-id}

Any MCP client can connect - your workspace’s exact URL is on Settings → MCP Clients once you’re in.

Plugs into the tools you already use

Helen’s Foundry 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
  • Sentry
  • Any MCP client

An editor for your thinking, not your prose

Helen is the AI built into Helen’s Foundry. She doesn’t improve your writing, she interrogates your reasoning.

Helen

This strategy commits to enterprise-only, but the goal beneath it doubles self-serve signups. Which one is the real plan?

  • 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.

The team building Helen’s Foundry

A two-person founding team shipping the strategic intent layer for AI agents.

  • Founder & CTO

    Justin Poehnelt

  • Founder & CEO

    Ashley Maguire

Get early access

Free to use. Rough around the edges.

Helen’s Foundry is invite-only early access. It’s free, it’s rough, and your feedback shapes what ships next. Join the waitlist and we’ll set up your workspace and send you a link.

Prefer email? Reach us at 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.