Home โ€บ Blog โ€บ Harness Architecture Comparison
Harness Engineering ยท Product Case Studies #4โ€“#11 ยท Snapshot: September 2026 ๐Ÿ›๏ธ

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.

How to read this: the remaining product case studies after OpenAI, Anthropic and DeepSeek. Facts come from each vendor's documentation and announcements, checked in September 2026 (see References). Products rename and repackage often; "coverage" scores are our own classification of documented first-party capabilities, not vendor claims, and not a ranking.

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:

โ–ถ Coverage map โ— core product ยท โ— provided/partial ยท ยท not provided (our classification of first-party features).
Click a product row or a layer column.

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.

โ–ถ Prompt agent vs hosted agent Toggle; orange = managed by Microsoft, blue = developer-owned.
2026 status: Foundry Agent Service is generally available with private networking and enterprise evaluations; hosted agents reached general availability in summer 2026, and Foundry agents can publish to Microsoft 365 Copilot and Teams (GA June 2026).

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.

โ–ถ Where does the same ADK agent run? Pick a deployment target.
2026 renaming: at Cloud Next on 22 April 2026 Google rebranded Vertex AI as the Gemini Enterprise Agent Platform, and Agent Engine became Agent Runtime โ€” adding long-running operations of up to 7 days, sub-second cold starts and provisioning under a minute. Existing agents kept running under the new names.

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:

โ–ถ The four layers Click to see what each adds.
โ–ถ LangGraph checkpoints: resume after a crash or an approval pause Each node's state is checkpointed. Press play.

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.

โ–ถ A flow that calls a crew Press play: the deterministic flow (top) hands one step to an autonomous crew (bottom).

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

โ–ถ Event history and replay Press play: the worker crashes mid-workflow; another worker replays the history.

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:

โ–ถ Sandbox lifecycle Click the actions; watch state and memory.
Documented behaviour: pausing a sandbox saves both file-system and memory state; resuming (about a second) restores files, running processes and loaded variables. Paused sandboxes are kept until explicitly killed. Snapshots let an agent fork one sandbox into parallel branches to explore different trajectories.

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.

โ–ถ A goal becomes browser actions "Find the cheapest refundable fare to Berlin next Friday." Press play.

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.

โ–ถ Two calls to a running agent Press play.

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:

โ–ถ Stack composer Pick a product for each role; the stack and a request path update.

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.

11 Synthesis: Architecture Roles and Product Mapping

๐ŸขManaged agent platformend-to-end agent serviceMicrosoft Foundry Agent Service
๐ŸงฐCode-first framework / runtimeagent dev kit, open runtimeGoogle ADK + Agent Runtime
๐ŸฆœAgent frameworkdeep agents + graph runtimeLangChain stack
๐Ÿ‘ฅMulti-agent frameworkflows + crewsCrewAI
โณDurable execution layerworkflows, event history, activitiesTemporal
๐ŸงชSandbox / compute layerisolated execution environmentsE2B
๐ŸŒBrowser / computer layercloud browser infrastructureBrowserbase
โ˜๏ธManaged agent runtimemodel-agnostic runtimeAmazon Bedrock AgentCore harness
Architectural principle: modern agent systems are compositional โ€” orchestration, durability, state, tools, sandboxes, browsers and observability can come from different products. Choose integrated platforms to move fast, specialist layers where you need depth or neutrality, and open standards (MCP, A2A, OpenTelemetry) to keep the seams replaceable.
The comparison in one paragraph
Across eleven product case studies the same architecture keeps appearing โ€” a control plane that runs the reasoning loop over durable state, and an execution plane of tools, sandboxes and browsers โ€” but vendors draw the managed/owned line in very different places. The hyperscalers (Microsoft Foundry, Google's Agent Runtime, AWS AgentCore) now each sell a managed harness with identity, governance and observability built in, and AgentCore bundles the widest set of first-party layers. The frameworks (LangChain, CrewAI, ADK itself) keep agent logic portable and open. The specialists (Temporal for durability, E2B for sandboxes, Browserbase for browsers) win on depth in one layer and plug into everything. Most real systems will mix all three kinds; the design task is choosing which seams you own.

Next: Agentic Developer Workbenches: Cursor, GitHub Copilot, Google Antigravity 2.0 and Devin Desktop Compared โ†’

โš ๏ธ Notes

The source infographic's architectures match public documentation; updates and refinements as of September 2026: (1) Google โ€” its Observability panel lists "Vertex AI (models, evals)"; Vertex AI was renamed the Gemini Enterprise Agent Platform on 22 April 2026, when Agent Engine also became Agent Runtime (the name the infographic already uses); (2) AgentCore harness โ€” worth adding that it is built on the open-source Strands Agents framework, reached general availability in June 2026 after an April preview, and runs each session in its own microVM; (3) Microsoft Foundry distinguishes prompt agents (no code) from hosted agents (your code, generally available in summer 2026) โ€” the infographic shows both but not the distinction's significance; (4) LangSmith Deployment is the current name of what was the LangGraph Platform. Coverage scores in the map, composer and script are our classification of documented first-party capabilities; lifecycle and flow animations are simplified illustrations.

๐Ÿ”— References