Harness Product Architecture Comparison: Foundry, ADK, LangChain, CrewAI, Temporal, E2B, Browserbase and AgentCore
The first three product case studies went deep on one harness each. This one goes wide: eight more platforms, architecture only โ how each structures runtimes, state, tools, execution and deployment, what it manages and what it leaves to you, and how they compose into a full stack. With an interactive coverage map, per-product architecture explorers, lifecycle animations, a stack composer and a runnable set-cover model.
01 Architecture Roles and the Coverage Map
The eight platforms play different roles: managed agent platforms (Foundry, AgentCore), a code-first framework with a managed runtime (Google ADK), agent frameworks (LangChain, CrewAI), a durable-execution layer (Temporal), a sandbox layer (E2B) and a browser layer (Browserbase). Click a product to see which harness layers it provides:
02 Microsoft Foundry Agent Service
Role: managed agent platform โ end-to-end agent service on Azure.
Foundry (formerly Azure AI Foundry) runs agents behind a Foundry endpoint with Entra ID identity and RBAC. It offers two shapes: prompt agents โ define instructions, model and tools, and Foundry runs the agent with no code or infrastructure โ and hosted agents, where you bring your own code (Microsoft Agent Framework, LangGraph, Semantic Kernel or custom) and Foundry hosts it in per-session isolated environments. Around both: a tools service (built-in tools and connectors), session persistence, data proxies into customer resources, evaluations, observability and private networking.
03 Google ADK + Agent Runtime
Role: code-first framework plus managed runtime.
The Agent Development Kit is Google's open-source framework (Python, Java, Go, Kotlin) for agent code โ generation, planning, tools, MCP and A2A connectors, multi-model access, sessions, state and memory. Deployment has three options: the fully managed Agent Runtime (containerized, auto-scaled, persistent sandboxes), Cloud Run (serverless, your configuration) or GKE (your Kubernetes). Observability and evals come from Cloud Trace, Cloud Logging and the platform's evaluation service.
04 The LangChain Stack: Deep Agents + LangChain + LangGraph + LangSmith
Role: agent framework โ a layered, open-source stack with a managed deployment option.
Four layers, each usable alone: Deep Agents (a batteries-included harness: orchestration, skills, tools and integrations, memory), LangChain (agent primitives, model interfaces, tool abstractions), LangGraph (the durable runtime: stateful execution, persistent checkpoints, human-in-the-loop) and LangSmith (deployment, autoscaling, tracing, evals and monitoring). Click a layer:
05 CrewAI: Flows + Crews
Role: multi-agent framework โ deterministic flows around autonomous crews.
CrewAI separates two kinds of control. Flows are deterministic orchestration: event-driven workflow steps, state management, conditions and branching, tool calls, resume and error handling. Crews are autonomous agent teams: a manager or coordinator and specialized agents (roles, goals, tools) that collaborate and hand back task outputs. A flow can call a crew as one step โ predictability where you need it, autonomy where it helps.
06 Temporal: the Durable Execution Substrate
Role: durable execution layer โ under any agent framework.
Temporal doesn't provide agent logic; it makes agent logic durable. Your workflow (a state machine written as ordinary code) calls activities โ model calls, HTTP requests, human approval, custom code โ which run on workers in your infrastructure. The Temporal service records every step in an event history, the source of truth: if a worker dies, another replays the history and continues exactly where it stopped, with automatic retries, timers and long waits, versioning and signals. Temporal raised $550M at a $12.55B valuation in September 2026 on this bet (see the market lens).
07 E2B: the Agent Execution / Sandbox Layer
Role: sandbox layer โ isolated compute for any agent.
Any agent or harness (OpenAI, Anthropic, LangChain, CrewAIโฆ) calls the E2B API/SDK to get a sandbox: a Firecracker microVM per session with a persistent file system, shell, package installs, a code runtime (Python, Node and more), controlled network access, optional GPUs, runtime-injected secrets and persistent artifacts. Its distinctive feature is the lifecycle:
08 Browserbase: the Browser / Computer-Use Layer
Role: browser and compute layer โ cloud browsers for agents.
Agents call the Browserbase API/SDK for cloud browser sessions: a fleet of isolated browsers with session management (create, resume, persist), identity and anti-detection ("stealth": fingerprints, proxies, CAPTCHA handling), warm instances, recordings and a live debugger. On top sits Stagehand, its open-source automation SDK, where natural-language goals become browser actions (act, extract, observe) on public websites, internal web apps and enterprise systems.
09 Amazon Bedrock AgentCore Harness
Role: managed, model-agnostic agent runtime.
AgentCore is AWS's set of agent services โ Runtime, Memory, Gateway (tools and APIs as MCP), Identity, built-in Browser and Code Interpreter tools, and Observability. The AgentCore harness, in preview from 22 April 2026 and generally available since June 2026, packages them into a managed agent: two API calls โ CreateHarness (model, instructions, tools) and InvokeHarness โ and AWS runs the orchestration loop, executes tools, manages the context window, persists state, recovers from failures and isolates every session in its own microVM with a file system and shell. It is built on the open-source Strands Agents framework and is model-agnostic: Amazon Bedrock models, OpenAI, Google Gemini and other LiteLLM-compatible providers, switchable mid-session.
10 Composing a Stack
Modern agent systems are compositional: orchestration, durability, state, tools, sandboxes, browsers and observability can come from different products. Choose one per role and see what you've built:
Which minimal combinations cover every layer? This script searches all combinations of the eight products using the coverage classification from section 01:
"""Which products cover which harness layers - and what is the smallest stack that covers them all?
Coverage below is our classification of each product's publicly documented, first-party
capabilities as of September 2026 (2 = core product, 1 = provided/partial, 0 = not provided;
integrations with third parties don't count). Standard library only.
"""
from itertools import combinations
LAYERS = ["orchestration", "state/sessions", "tools/MCP", "code sandbox", "browser",
"durable execution", "observability/evals", "managed hosting", "identity/governance"]
C = { # product: coverage per layer, in LAYERS order
"Microsoft Foundry Agent Service": [2, 2, 2, 1, 1, 1, 2, 2, 2],
"Google ADK + Agent Runtime": [2, 2, 2, 1, 0, 1, 2, 2, 2],
"LangChain stack": [2, 2, 2, 0, 0, 2, 2, 2, 1],
"CrewAI": [2, 2, 1, 0, 0, 1, 1, 2, 1],
"Temporal": [1, 2, 0, 0, 0, 2, 1, 2, 1],
"E2B": [0, 1, 0, 2, 1, 0, 0, 2, 1],
"Browserbase": [0, 1, 1, 0, 2, 0, 1, 2, 1],
"Amazon Bedrock AgentCore": [2, 2, 2, 2, 2, 1, 2, 2, 2],
}
print(f"{'product':<34}" + "".join(f"{l[:10]:>11}" for l in LAYERS) + f"{'core':>6}")
for p, v in C.items():
print(f"{p:<34}" + "".join(f"{'โโ' if x == 2 else 'โโ' if x == 1 else 'ยทยท':>11}" for x in v) + f"{sum(x == 2 for x in v):>6}")
def covers(stack, need=2):
return all(any(C[p][i] >= need for p in stack) for i in range(len(LAYERS)))
print("\nSmallest stacks where every layer is a *core* capability of some product:")
for k in range(1, 5):
found = [s for s in combinations(C, k) if covers(s)]
if found:
for s in found[:6]: print(f" {k} products: " + " + ".join(s))
print(f" ({len(found)} combinations of {k})")
break
print("\nThe same search without the three hyperscalers (cloud-neutral stacks):")
neutral = [p for p in C if not p.startswith(("Microsoft", "Google", "Amazon"))]
for k in range(1, 6):
found = [s for s in combinations(neutral, k) if covers(s, need=1) and all(any(C[p][i] == 2 for p in s) for i in range(7))]
if found:
for s in found[:3]: print(f" {k} products: " + " + ".join(s))
break
print(" (identity/governance and managed hosting relaxed to 'provided')")
print("\nHow many products offer each layer as a core capability:")
for i, l in enumerate(LAYERS):
core = [p.split()[0] for p in C if C[p][i] == 2]
print(f" {l:<20} core in {len(core)}: {', '.join(core)}")Output:
product orchestrat state/sess tools/MCP code sandb browser durable ex observabil managed ho identity/g core Microsoft Foundry Agent Service โโ โโ โโ โโ โโ โโ โโ โโ โโ 6 Google ADK + Agent Runtime โโ โโ โโ โโ ยทยท โโ โโ โโ โโ 6 LangChain stack โโ โโ โโ ยทยท ยทยท โโ โโ โโ โโ 6 CrewAI โโ โโ โโ ยทยท ยทยท โโ โโ โโ โโ 3 Temporal โโ โโ ยทยท ยทยท ยทยท โโ โโ โโ โโ 3 E2B ยทยท โโ ยทยท โโ โโ ยทยท ยทยท โโ โโ 2 Browserbase ยทยท โโ โโ ยทยท โโ ยทยท โโ โโ โโ 2 Amazon Bedrock AgentCore โโ โโ โโ โโ โโ โโ โโ โโ โโ 8 Smallest stacks where every layer is a *core* capability of some product: 2 products: LangChain stack + Amazon Bedrock AgentCore 2 products: Temporal + Amazon Bedrock AgentCore (2 combinations of 2) The same search without the three hyperscalers (cloud-neutral stacks): 3 products: LangChain stack + E2B + Browserbase (identity/governance and managed hosting relaxed to 'provided') How many products offer each layer as a core capability: orchestration core in 5: Microsoft, Google, LangChain, CrewAI, Amazon state/sessions core in 6: Microsoft, Google, LangChain, CrewAI, Temporal, Amazon tools/MCP core in 4: Microsoft, Google, LangChain, Amazon code sandbox core in 2: E2B, Amazon browser core in 2: Browserbase, Amazon durable execution core in 2: LangChain, Temporal observability/evals core in 4: Microsoft, Google, LangChain, Amazon managed hosting core in 8: Microsoft, Google, LangChain, CrewAI, Temporal, E2B, Browserbase, Amazon identity/governance core in 3: Microsoft, Google, Amazon
Only AgentCore offers a browser and a code sandbox as first-party services alongside orchestration, so it anchors every two-product answer; durable execution, the rarest core capability, comes from LangGraph or Temporal. Without a hyperscaler, three products do it: an agent framework plus a sandbox layer plus a browser layer โ exactly the modular pattern the specialist vendors are built for. The classification is ours and simplifies; the point is the shape of the market, not a verdict.