An agent framework is a library for composing models, tools, and control flow. An agent harness is the running environment around a model: the loop, the tools as they are actually granted, the stops, the sensors, and the identity that production will use.

LangChain’s own docs are careful with the words. Agent = Model + Harness. create_agent is “a highly configurable harness.” Deep Agents is “the batteries-included agent harness.” LangGraph is the low-level orchestration framework when the built-in loop is the wrong shape. That taxonomy is the whole article: a framework can implement a harness. Shipping the pip package does not mean you have one operators can hire.

LangChain’s custom-harness post says the same from the other side. Pre-assembled harnesses (Deep Agents, Claude Agent SDK) get you to a working agent fast. create_agent is minimal on purpose: core loop plus middleware. You still choose tools, guardrails, and business logic. CrewAI, Semantic Kernel, AutoGen, and Pydantic AI live in this neighbourhood. They are how engineers assemble loops. They are not a substitute for write-back governance, a workstream, or a ledger.

Claude Code and Cursor are harnesses you run, not frameworks you import. Nimbus, Palantir AIP, and Agentforce are (different) harnesses you run for company jobs. Confusing “we use LangGraph” with “we have an enterprise harness” is the 2026 version of “we use Kubernetes” meaning “we have a product.”

Words you’ll hear

Framework. SDKs and graphs: LangChain, LangGraph, CrewAI, AutoGen, Semantic Kernel, Pydantic AI. You write code. You own production identity unless you add it.
Harness. Runtime around the model. What is an agent harness. May be a product (Claude Code) or a configured framework (your create_agent plus hooks plus IdP).
Middleware / hooks. Framework primitive that becomes harness behaviour when it always runs. LangChain middleware; Claude Code hooks.
Batteries-included harness. Deep Agents, Claude Agent SDK, Codex SDK. Opinionated loop, filesystem, subagents, compaction. Still not your CRM grant model.
Orchestration framework. LangGraph when you need deterministic nodes mixed with agentic ones. Powerful. Easy to put the orchestrator in a system prompt and call it done.
MCP. Plug. What is Model Context Protocol. Works behind frameworks and products. Does not choose the framework/harness cut.

In Nimbus you do not import a graph to start a job. You assign an agent team on a workstream. Under the hood there is still a loop, tools, and stops — a harness. The product choice is whether operators must be graph authors. Self-service vs forward-deployed.

Why you should care

Engineers will prefer frameworks. They should. Control, portability, tests in CI. Operators and Legal will prefer a harness they can inspect without a pull request. McKinsey keeps showing isolated technical use without operating-model change. A beautiful LangGraph in a platform team’s repo is still isolated use if RevOps cannot attach Salesforce or refuse a write.

It affects you if:

the RFP says “must support LangChain” as if that were a control
a vendor says “model-agnostic framework” and prices seats on one flagship
you are asked to rebuild quoting and SoD because “we already have agents in Python”
security reviews the GitHub org and never reviews who can call PATCH

OWASP’s LLM Top 10 excessive agency shows up in both: a framework that exposes every tool by default, or a product that does. The cut is not safety vs convenience. It is who can change the harness when it fails — harness engineering — and whether a fail-closed write exists.

NIST AI RMF Map/Measure need a system boundary. “Our framework” is not a boundary. A named runtime with grants and logs is.

The practical differences

Who authors the loop. Framework: software engineers. Product harness: operators (and maybe SE for custom tools). If only engineers can add a sensor, you will wait on a sprint for a Legal rule.

Where identity lives. Framework default: service account in .env. Product harness: org roster, workstream membership, OAuth grants. You can do the latter in LangGraph. You must build it.

What “done” means. Framework: your node returned. Inner product harness: tests / hook. Outer product harness: signer. Anthropic’s effective agents and long-running harness notes are about encoding done in the environment. Frameworks give you the primitives; they do not know your done.

Portability. Frameworks win on model swap if tools and middleware stay. Product harnesses win if they actually route and do not bury a flagship default in a seat. Model routing. “We wrap LangChain” is not routing.

Eval. Frameworks shine in unit tests of nodes. Inner harnesses shine on SWE-bench / Terminal-Bench. Enterprise harnesses shine when quote hash equals SoR row. Different CI.

Time-to-first-governed-write. Framework: months unless you already built the interceptor. Forward-deployed OS: months of people. Self-service outer harness: the product’s week-one claim — verify it. Proof of value.

Lock-in. Framework lock-in is code and patterns. Product lock-in is data, graph, and operating habits. Both are real. How to solve model lock-in is the model slice; harness lock-in is the loop slice. Prefer quoted payloads and exportable ledgers either way.

LangChain is not the villain. Their anatomy post is one of the clearer public derivations of harness parts. Use it. Then ask whether your deployment has those parts for the job you are buying — repo or company. Inner vs outer.

Nimbus’s bet is that most operators should not author LangGraph to update a discount cap. The wiki and the gate should move. Teams that should author graphs (unique simulation, exotic tools) can still sit behind a connector. Framework inside a harness. Not a framework instead of one.

A decision rule

Building a product or a unique workflow in code, with engineers on the hook: framework (or SDK harness) plus your own grants and evals.
Hiring a loop for a repository: inner product harness (Claude Code, Cursor, Codex). Optionally extend with a framework for custom tools.
Hiring a loop for CRM/ERP/cross-department work: enterprise agent harness / OS-class product. A framework is a build programme.
Vendor says “we are a framework and an OS”: make them show a failed unsigned write and an operator-attached connector. Words are cheap.

Build vs buy an enterprise AI OS is the longer form of the third bullet.

What each layer of the stack is for

LangChain’s own split is the cleanest vendor-native map: use Deep Agents when you want a batteries-included harness; use create_agent when you want a minimal harness you customise with middleware; drop to LangGraph when the agent loop is the wrong shape and you need deterministic nodes mixed with agentic ones; use LangSmith to trace whatever you built. That is a builder’s menu. It does not decide whether RevOps can refuse a write.

CrewAI is a role-and-task framework. AutoGen is a conversation-of-agents framework. Semantic Kernel is Microsoft’s orchestration SDK. Pydantic AI moved toward a “harness-first” design in 2026 (capabilities as tools + hooks + instructions). None of these are wrong. All of them leave identity, SoR quoting, and operator self-service as your story unless you add them. OWASP will still fail you if the first graph you merge attaches every production tool “so the demo looks alive.”

Product harnesses fail the other way: they hide the graph so operators can work, then surprise engineers who wanted to unit-test a node. Demand an escape hatch — export traces, typed payloads, maybe a documented tool SDK — without requiring every discount cap to be a pull request. Nimbus’s bet is that the cap lives in the wiki and the interceptor, and that engineers who need a custom simulator put it behind a connector. Framework inside the harness.

Thoughtworks would say a company that standardises on LangGraph has invested in layer 2 (builder) and still has to build layers 3–4 (user guides/sensors, organisational ownership). A company that buys only a coding harness has a strong inner layer 2–3 and a missing outer layer 4. A company that buys an OS-class product is hoping layer 3–4 shipped. Verify with a refused write, not with a README.

Cost of the wrong cut. Framework-first for operators: six months of platform work, then shadow copilots anyway. Product-first for a unique research loop: you will fight the product and rebuild the graph in Python by week four. How to choose coding vs enterprise plus this page: workspace first, then assemble vs hire.

Portability, honestly. Frameworks make model swap easier if you used their model interface and did not sprinkle vendor-specific tool formats through application code. Products make operator ratchet easier if adding a gate is a UI action. Neither gives you portability of decisions unless the ledger exports. Ask for JSON of the quote and the graph, not a promise of “open.”

Inngest and others have argued that durable execution needs “a harness, not a framework”: retries, state, and recovery as infrastructure. That slogan is directionally right for production. It is incomplete for enterprises. Durable retries of an unsigned write are a reliable incident. The outer harness adds identity and a stop that retries must not bypass. LangGraph checkpointing is excellent loop infrastructure. It is not a Finance signer.

A worked split: the data-science team builds a forecasting graph in LangGraph, evaluates it with their own sensors, exposes it as a tool. RevOps never opens the repo. They brief a workstream, the team calls the forecast tool under read scope, and any CRM write still quotes in the product interceptor. Framework for the specialist. Harness for the company job. Nimbus is the second box; it should consume the first as a connector, not replace the scientists’ graph. Integrations.

If your platform team’s OKR is “stand up LangChain,” add a second OKR: “unsigned SoR writes are impossible.” The first without the second is a framework programme. The second without any loop is a policy PDF. You need both, in that order of safety.

CrewAI marketing will talk about roles. Roles in a YAML file are not roster identity. If the “legal reviewer” crew member can still call the same Salesforce write tool as the “AE,” you have a framework demo of agent teams without the contract. Ask to see the tool belt per role, then ask what happens when you remove the write tool from legal and the model asks for it anyway. The harness answer is refuse. The framework-only answer is often “we’ll prompt it.”

Agent Harness vs Agent Framework

Words you’ll hear

Why you should care

The practical differences

A decision rule

What each layer of the stack is for

Questions people actually ask

Is LangGraph a harness?

Is Claude Code a framework?

Does MCP replace both?

We already standardised on CrewAI.

How do we evaluate a vendor who wraps LangChain?

Where does Nimbus sit?

Sources

Related guides

Inner vs Outer Agent Harness

What is RBAC for enterprise AI, and why should you care?

See what governed AI looks like on your stack.