foundr.companyby Perea
← foundr.work·Soon

foundr.work — market insights

MECE market analysis. Numbers are point-in-time (May 2026) — sources linked so you can re-verify. TAM > SAM > SOM are nested slices, not aspirational forecasts.

TAMTotal addressable

$11.0B / yr (2025) → $30.2B by 2030 (22.3% CAGR)

Proxy

AI orchestration market (agent orchestration platforms + agent builders + model serving + durable execution) per MarketsandMarkets. Cross-checks: AI agents market $7.84B → $52.6B (46.3% CAGR); agentic orchestration + memory $6.27B → $28.45B (Mordor).

Calc

$11.02B (2025) → $30.23B (2030) at 22.3% CAGR (MarketsandMarkets AI Orchestration). The orchestration/runtime layer foundr.work plays in is the convergence of three published markets — AI orchestration, AI agents, and agentic memory.

Sources
SAMServiceable addressable

~$2.0B / yr (2026), reaching ~$8B by 2031

Proxy

Agentic AI **frameworks** sub-segment (OSS-friendly, excludes hyperscaler-locked platforms). OSS share is 63.8% of framework market in 2025 (Mordor).

Calc

Agentic AI frameworks market = $2.99B (2025) → $4.11B (2026) → $19.3B (2031) at 36.3% CAGR. OSS-friendly share (~64%) × addressable-to-small-teams (~50%) = $1.3–2.0B in 2026 SAM. ARPU benchmark: $29–$199/mo × ~5–10M weekly TS/Python agent devs (Mastra 300K weekly npm DLs, LangChain 90M monthly DLs, Pydantic-AI 17K stars).

Sources
SOMServiceable obtainable (3–5 yr)

$15–30M ARR by year 3; $60–120M by year 5

Proxy

OSS-first → hosted-runtime conversion. Vercel/Next.js + Mastra/Cloud + LangSmith precedent.

Assumptions
  • OSS conversion to hosted = 1–2% (Elastic / OpenView precedent: ~1% converts but builds multi-billion ARR)
  • Year-3 target: 200K weekly npm downloads (Mastra hit 300K in 15 months) × 1.5% conversion = 3,000 paying accounts × $80/mo blended ARPU ($29 Solo / $199 Pro mix) = ~$35M ARR ceiling
  • Year-5 target: 600K weekly + 2% conversion + $100 ARPU = $144M ARR ceiling
  • Pricing anchored to indie hackers — 5–10× cheaper than Temporal Cloud ($100/mo floor)
Analog precedent

Mastra: 22K stars + 300K weekly npm DLs + $13M YC seed in 15 months (Jan 2026). LangChain: $16M ARR / 1K customers / 90M monthly DLs / $1.25B valuation. Temporal: 380% YoY revenue growth, 20M installs/month, $5B valuation. Vercel: Next.js OSS → $340M ARR over ~10 years.

Sources

The top 3 incumbents

Who controls the market — and why they can't pivot.

Each incumbent's vulnerabilities tagged by kind: technical, business model, regulatory / channel, cultural.

#1LangChain / LangGraph

$1.25B valuation, $16M ARR, 90M monthly DLs, 118K stars

  • Tech debt

    LCEL pipe operator + private `#graph` field cause silent state loss across thread boundaries (Issue #10144). Cross-thread checkpoint contamination in multi-tenant prod (Issue #2040). Stale `structured_response` from checkpoint causing premature exit (Issue #36957). Five+ years of v0.x breaking changes across four repos (langchain, langgraph, langsmith, langgraph-checkpoint-postgres).

  • Business model misalignment

    LangSmith (paid) is observability OVER LangChain code — pulls users toward Python + graph-builder paradigm. Sequoia/IVP-class burn forces enterprise sales motion (~35% of F500 logos) that ignores solo founders.

  • Regulatory / channel dependency

    Sales anchored on LangGraph Platform + LangSmith Cloud. Their cloud IS the monetization wedge — releasing a portable, hosted-optional declarative DSL would torpedo their $125M Series B thesis.

  • Cultural / incentive trap

    Built around "we abstract LLM complexity." Model providers absorbed function calling, structured outputs, memory, tool routing in 18 months. The abstraction is shrinking faster than the company can pivot.

#2CrewAI

~$100M valuation, 60% F500 logos, 450M agents / month, 47.8K stars, ~$3.2M ARR, $18M Series A (Insight)

  • Tech debt

    `ChatWithCrewFlow.__init__` makes blocking LLM call at module import — crashes containers on any LLM hiccup, fails k8s/Railway health checks (Issue #5510). `output_pydantic` leaks into tool-calling loop, skips tool execution on non-OpenAI LLMs since v1.9.0 (Issue #5472).

  • Business model misalignment

    CrewAI AOP (Agent Operations Platform, Nov 2025) is observability/governance for enterprises. Seven-figure deals with KT, PwC, IBM, Capgemini are the revenue. Solo founder running a single agent isn't a customer — they're a top-of-funnel demo. Tier gap: free → Basic $99 → Standard $6k/yr → Ultra $120k/yr leaves the indie tier wide open.

  • Cultural / incentive trap

    "Role + goal + backstory" Python metaphor pre-dates Claude Code's rise as the dominant agent IDE. 230K DeepLearning.AI course completions with Andrew Ng compound the Python lock-in — pivoting to YAML/TS would orphan the educational moat.

#3Mastra

$13M YC seed, 24K stars, 300K weekly npm DLs, Replit/PayPal/Adobe as customers

  • Tech debt

    `agent.network()` hardcodes routing prompts that override user instructions — agents auto-execute past "wait for input" gates (Issue #9137). Sub-agent threads start fresh, losing parent context (Issue #13825). Supervisor mode doesn't forward client tools to sub-agents (Issue #15247). Approval mode serializes parallel sub-agent calls (Issue #15887).

  • Business model misalignment

    Mastra Cloud is the monetization. Code-first SDK (`new Agent({...})` in TS) — every config is bespoke code, not portable spec. No declarative surface a non-TS engineer can audit. Tier jump from Starter $0 → Teams $250/mo skips the solo founder.

  • Cultural / incentive trap

    Gatsby alumni founders → frontend-framework DNA → assume "TypeScript IS the answer." YAML/declarative would be a positioning rewrite. Closest direct competitor; their advantage is funding, their weakness is the code-first surface.

Strategic moves (12 mo)

Ranked by leverage. Top of the list ships first.

Leverage is encoded in position — no fake score. #1 is the highest-leverage move we can make in the next quarter.

  1. 01

    Ship the Claude Code skill bundle as the install path

    Q1

    `claude mcp add foundr-work` should be the README's first command. Distribution into 100K+ Claude Code seats beats any landing-page funnel. Time-pressured: the Claude Code adoption curve is steepest now.

  2. 02

    Steal the LangChain exit narrative

    Q1

    Every week brings a fresh "we replaced LangChain with 200 lines" post (Medium, AWS in Plain English, OctoClaw, Logic.inc). Publish a `langchain-to-foundr-work` codemod + migration guide. Free attention.

  3. 03

    Open-source a public registry of `worker.yaml` recipes

    Q2

    Copy the Vercel "starter kits" playbook that drove their OSS → paid funnel ("clone repo, add Stripe key, deploy"). Recipes = SEO + share virality + zero-to-running in 5 minutes.

  4. 04

    Ship durability as a Postgres / SQLite adapter, not a hosted service

    Cloudflare Agents already has 790K weekly npm DLs by being free + persistent on Durable Objects. Make self-hosted durability work; let `$29/mo Hosted Solo` be the convenience tax, not the only option.

  5. 05

    Land 5 indie-hacker design partners running 5 production foundr-workers each

    Q2

    Mastra closed PayPal/Adobe/Replit via case studies; our audience is a tier below — easier to land, faster to ship. Case-study copy beats any ad spend.

  6. 06

    Compete head-on with Inngest AgentKit (845 stars)

    They have the right idea (deterministic routing, MCP-first) but no declarative surface. Frame foundr.work as "AgentKit + YAML + portable." Their tiny star count means the niche is still wide open.

  7. 07

    Mint a benchmark: "Stateful agent ops per dollar"

    Q3

    Temporal Cloud $100/mo, LangGraph Platform usage-priced, Mastra Cloud tiered, foundr.work Hosted Solo $29. Publish a head-to-head benchmark. Cheap PR with a moat-shaped narrative.

Economic moats

What we can hold — and what we can't.

Honest split. We refuse to call cost-leadership or distribution a moat unless it actually defends.

Real (defensible)

  1. 01

    Claude Code / Codex skill-native distribution

    Anthropic's CLI is the agent-engineer's IDE. A skill bundle installed via `claude mcp add` becomes muscle-memory. CrewAI/LangChain cannot retrofit this without abandoning their Python-decorator surface.

  2. 02

    YAML spec as the artifact

    Once a team has 20 `worker.yaml` files in git, that's a corpus of reproducible specs that compounds. Frameworks store agents as code — harder to lift, but also harder to audit/share. We win on portability + auditability.

  3. 03

    Recipe registry network effect

    Every published recipe lowers time-to-first-worker for the next user. Vercel's starter-kits playbook proved this; LangChain has integrations, not recipes — different graph entirely.

Not real (incumbents can match)

  1. 01

    Durability / replay

    Temporal / Inngest / LangGraph Platform all have it. Ours is table stakes — the price point ($29) and indie-shape are the wedge, not the capability.

  2. 02

    Multi-provider LLM routing

    LiteLLM / OpenRouter commoditized this. Every framework supports it; nobody can sell on it alone.

  3. 03

    MIT license + BYO key

    Pydantic-AI, smolagents, Agno, Mastra OSS all do this already. Required to enter, not a moat.

Switching costs in our favor

  • Once the founder has cron'd 5 foundr-workers, ripping them out means recreating the YAML in Python — the spec IS the lock-in (without being closed)
  • Skill-bundle install means uninstalling foundr-work breaks the founder's Claude Code muscle-memory
  • Recipe registry membership: published recipes earn citations + traffic that stay tied to the contributor

Switching costs against us

  • Solo founders churn fast — if Hosted Solo gives them durability they can replicate with `pg-boss` + Postgres, they will. The hosted tier needs replay + dashboards to defend $29/mo
  • A vibe coder who paid $29 will downgrade to BYO Postgres the moment cash is tight
  • YAML is portable: a competitor could write a "foundr-work → LangGraph" transpiler in a weekend

Power-user pain

5 unaddressed pains, real voices.

Each pain has ≥3 independent quotes from Reddit / HN / GitHub / X. If an incumbent could fix it, they would have already.

Pain A

Abstraction tax + debugging through framework internals

  • “Spent a good amount of time trying to use it… ultimately dropped it. It made my head hurt.”

    — HN user — news.ycombinator.com/item?id=40739982

  • “Five layers of abstraction just to change a minute detail.”

    — HN user — news.ycombinator.com/item?id=40739982

  • “Stack traces become unreadable and overwhelming. Engineers spend hours debugging framework logic they did not write.”

    — upgrad.com — Why Are Developers Quitting LangChain?

Why incumbents
can't fix

LangChain's $125M Series B explicitly funds LangGraph (the lower-level orchestrator). Removing abstraction means orphaning their 1.0 release and 90M monthly DLs.

Coverage

✅ Shipped YAML spec has no class hierarchies. Engine traces map 1:1 to spec lines. The thing that runs is the thing you wrote.

Pain B

State silently lost across threads / restarts / checkpoint boundaries

  • “Cross-thread checkpoint data contamination… Data from one conversation appears inside another thread's checkpoint and LLM responses.”

    — pepinogttv — github.com/langchain-ai/langgraphjs/issues/2040

  • “When invoking the tool-call subgraph, the main agent loses the memory of previous tool invocations.”

    — education-01 — github.com/langchain-ai/langgraph/issues/7117

  • “Messages are silently lost… Inspecting `.langgraphjs_api.checkpointer.json` shows it stays empty.”

    — anishgurjar — github.com/langchain-ai/langchainjs/issues/10144

Why incumbents
can't fix

State management is split across langchain, langgraph, langgraph-checkpoint-postgres packages with separate release trains. The singleton `AsyncLocalStorageProviderSingleton` design choice is load-bearing.

Coverage

❌ Gap foundr.work's declarative state machine is the differentiator we need to ship before the $29 hosted tier matters. State as a first-class spec field, persisted by the runtime, not by user-wired checkpointers.

Pain C

Agent runtime crashes container on transient LLM error

  • “`ChatWithCrewFlow.__init__` triggers synchronous blocking LLM calls at module import time… ANY LLM provider hiccup during container startup causes the Python process to crash before the HTTP server is listening.”

    — jpr5 — github.com/crewAIInc/crewAI/issues/5510

  • “Failed to parse ledger information after multiple retries… `progress_ledger = json.loads(ledger_str)` is not capable to handle the json string.”

    — vamsithumma2812 — github.com/microsoft/autogen/issues/6599

  • “Invalid response from LLM call - None or empty… Agent executor doesn't proactively check message length before calling the model — it only handles it after an exception is thrown.”

    — phuihock — github.com/crewAIInc/crewAI/issues/3454

Why incumbents
can't fix

Eager-init patterns and unvalidated LLM JSON parsing are baked into CrewAI / AutoGen execution loops. Fixing requires breaking-change API redesign.

Coverage

⚠️ Partial Hosted Solo durability tier resumes from last checkpoint on crash. OSS core needs the same default — lazy-init + validated parsing baked into the compile step.

Pain D

Vendor / control-plane lock-in once you adopt a platform

  • “Pick a control plane, and lock-in starts — quietly, across multiple layers, compounding with every month of deployment.”

    — softwareseni.com — How to Avoid Enterprise AI Agent Platform Lock-In

  • “Vendor lock-in… is the most common regret teams report after their first year of agent deployment.”

    — agentmelt.com — AI Agent Vendor Lock-In

  • “Every other AI agent platform requires you to use their cloud.”

    — JieGou — jiegou.ai/blog/ai-agent-platform-cloud-lock-in/

Why incumbents
can't fix

Hyperscaler platforms (Bedrock, Foundry, Vertex) ARE the lock-in. LangGraph's Platform/Cloud monetization requires gravity. CrewAI AOP IS the moat.

Coverage

✅ Shipped YAML spec + MIT + BYO key + npm install. The spec runs anywhere npm runs. No control plane, no cloud dependency for the OSS path.

Pain E

Agent frameworks are overkill for the actual problem most solo founders have

  • “I don't see the point of agent frameworks. Other than durability and checkpoints how does it help me? Claude code already works as an agent.”

    — HN — news.ycombinator.com/item?id=47070455

  • “I'm a full stack developer and have looked into LangChain and am daunted by its surface area. I'm trying to understand where and how exactly does it add value.”

    — HN — news.ycombinator.com/item?id=41141305

  • “After spending more time trying to decypher the LangChain docs than it would take to roll-my-own, everything I've done so far has involved rolling-my-own.”

    — HN — news.ycombinator.com/item?id=41141305

Why incumbents
can't fix

LangChain / CrewAI / Mastra are sized for enterprise feature parity. Acknowledging "solo founders don't need most of this" cannibalizes their TAM pitch to VCs.

Coverage

✅ Shipped foundr.work IS the "small surface area + durability + checkpoints" the HN crowd asked for. The README needs to say it in their words — "rolling-your-own + state + replay, in a YAML file."

Synthesis

Where SAM × incumbent vulnerability × unaddressed pain converges.

A wedge counts only when all three columns align. Status = what we've actually shipped against it.

WedgeSAM segmentIncumbent vulnPain solvedStatus
YAML over Python decoratorsSolo founders / Claude Code nativesCrewAI/LangChain locked to Python class hierarchiesFramework forces me to think like the framework✅ Shipped
Claude Code skill-bundle installAI-native solo devs in Claude CodeLangChain/CrewAI need `pip install` + tutorialI want it in my IDE, not another CLI to learn⚠️ PartialSOON — depends on framework launch
$29 hosted durability tierIndie hackers running 1–10 agentsTemporal $100 floor; CrewAI Enterprise = "talk to sales"; Mastra Teams $250 next stepDurable execution priced for indie scale⚠️ Partial
Stateful by spec, not by checkpoint plumbingTS/Py devs hit by LangGraph state-loss bugsLangGraph Issues #10144, #2040, #36957 — state silently disappearsProduction agent silently loses memory❌ GapCore differentiator — need to ship runtime
OSS + BYO key + zero accountSolo founders allergic to vendor lock-inHyperscaler agents lock to AWS/Azure/GCP; Mastra Cloud + LangSmith require signupDon't make me create another account✅ Shipped
Portable spec across runtimesMulti-cloud / sovereign customers"Control-plane lock-in is the deepest layer" (SoftwareSeni)Run the same agent on my laptop, lab, prod, customer's VPC❌ Gap
Replay + audit trail in OSS coreCompliance-aware solo foundersTemporal puts replay behind Cloud; LangSmith is paidI need replay without a paid plan❌ Gap

Capture strategy

Where foundr.work actually wins.

Each angle ties SOM capture to a specific incumbent vulnerability above.

See how we sell into that gap.

The market thesis lives here. The pricing, MCP surface, and feature list live on the features page.

Full features & pricing← Back to foundr.work