- Just curious what "AI agents" even are? Read the plain-language summary right below, then stop whenever you've had enough.
- Evaluating agent tools for your business? Read the summary, then skip to Section 5 (Comparative Analysis) and Section 7 (Conclusion) for the practical takeaways.
- Building agent systems yourself? The whole thing is for you, including the source citations.
The short version, in plain English
Three different "AI agent" tools keep getting compared to each other as if they're competitors, and they're not — they solve three different problems.
Picture building something with a friend. LangGraph is like a set of architect's tools: you design the blueprint yourself, decide exactly how each room connects, and build it on land you own. DeepSeek Harness is more like a prefab shed kit: someone else designed it and every piece is meant to be swapped or upgraded, but you still assemble it yourself, in your own yard, on your own property. Claude Cowork is like hiring a contractor who builds the thing in their own warehouse and delivers the finished product to your door — you never see the workshop, and the work never happens on land you own.
None of those is objectively "better." The right one depends on one question: do you need to control exactly where the work happens and who can see the data involved? If yes, you want the architect's tools or the prefab kit — not the contractor's warehouse. That single distinction is the entire argument of this report, and everything past this point is the evidence for it.
1. Introduction
Comparison posts, vendor content, and internal team debates routinely place an orchestration library, a standalone agent runtime, and a hosted product side by side, score them on the same feature checklist, and declare a winner — despite the three answering different questions about where the work happens and who's in control of it. That confusion is the actual subject of this report. We use three concrete, widely discussed tools as evidence: LangGraph (a toolkit you use to build and control your own agent system), DeepSeek Harness (a full agent application you install and run yourself), and Claude Cowork (a finished agent product that runs on its maker's servers).
This report makes three contributions:
1. A source-verified account of how DeepSeek Harness actually works internally, based on directly reading its public code rather than repeating what other blog posts say about it — including confirming, at the code level, exactly what data it does and doesn't send home by default. 2. Real production results from two systems we built ourselves on LangGraph, including a result we haven't seen reported anywhere else: a technique that's supposed to improve AI search accuracy (query rewriting) that made our legal-document search noticeably worse, and why we removed it. 3. A plain explanation — not a feature checklist — of why a cloud-hosted agent product like Claude Cowork simply cannot be used for work that has to stay on infrastructure you control, no matter how good the agent itself is.
If you're a non-technical reader: everything from here through Section 4 goes deeper into the evidence behind those three points. Section 5 pulls it back together into a plain comparison, and Section 7 is the takeaway.
2. Related Work
(This section situates our findings against existing research. Skip to Section 3 if you just want our own findings.)
Existing writing on AI agent tools tends to compare frameworks against each other, without asking whether they're even solving the same kind of problem. One recent survey compares six agent orchestration tools — LangGraph, CrewAI, AutoGen/Microsoft Agent Framework, OpenAI Agents SDK, MetaGPT, and DSPy — on things like how they manage state and what failure recovery looks like [1]. A related paper describes the last two years as a flood of similar frameworks — LangGraph, CrewAI, Google ADK, OpenAI's Agents SDK, Microsoft's Semantic Kernel, Amazon's Strands Agents, and LlamaIndex — that mostly work the same underlying way: a central controller keeps track of the conversation and tells the AI model what to do at each step [2]. Useful work, but it compares tools within one category — it doesn't ask which category a tool belongs in to begin with, which is the question this report focuses on.
Separately, DeepSeek Harness is built on a plugin system called Cordis, whose design is described in its own dedicated research paper [3]. In plain terms, that paper's contribution is a way to build software where literally every piece — down to the part of the program that decides what happens next — can be swapped out cleanly while the system is running, the way you might swap a part on a car without draining all the fluids first. That idea, explained formally in the paper as two properties its authors call "temporal" and "spatial" composability, is the actual reason DeepSeek Harness can claim that nothing in it is permanently fixed in place [3][4]. We treat that as relevant background, not a footnote, because it's the reason DeepSeek Harness's architecture behaves differently from an ordinary app with plugins bolted on.
3. Methodology
We used three different standards of evidence, and how confident you should be in each claim below depends on which one backs it.
1. DeepSeek Harness — we downloaded the actual public source code (deepseek-ai/deepseek-harness) at a specific saved snapshot (commit 99f6f02, dated 2026-08-17, version 0.1.0-rc.7) and read it directly, rather than trusting secondary write-ups. Where we describe internal behavior — like what data gets sent off your machine by default — it's because we found that behavior written into the project's own automated tests, not because a blog post claimed it.
2. LangGraph — this is our own first-hand experience: engineering decisions and results from two systems we designed, built, and measured ourselves, plus a documented internal comparison against a competing tool (Hermes Agent) before we chose LangGraph.
3. Claude Cowork — its inner workings are closed-source, so what we say about its architecture is sourced to Anthropic's own published documentation, checked against how it actually behaved when we used it ourselves.
To be upfront: this is not a lab test where we ran the identical task through all three tools and timed them. We did not run DeepSeek Harness or Claude Cowork through the same accuracy test we used on our own legal-document search system. That gap is real, and Section 6 addresses it directly instead of glossing over it.
4. Findings
4.1 LangGraph: production findings from two shipped systems
Legal contract-review search (RAG). We built a four-step pipeline — search, an AI double-check step, answer generation, and a final review step — that combines two different search techniques (a modern AI embedding model called BGE-M3 [10], plus a decades-old keyword-matching technique called BM25) and then re-ranks the results. Critically, the system is built to refuse to answer rather than guess: if it can't back up an answer with something it actually retrieved, it says so instead of making something up. Tested on CUAD [9] — a public dataset of 510 real commercial contracts with over 13,000 clauses hand-labeled by legal experts — the system got the right answer roughly 80% of the time as a starting baseline. In more technical terms, it scored 0.750 on Recall@5 (meaning the correct answer showed up somewhere in the top 5 results about three-quarters of the time) and 0.582 on MRR (a measure of how close to the very top result the correct answer tends to land).
Here's a finding we think is worth sharing precisely because it's a negative result, and those rarely make it into company blog posts: we tried a popular technique called "query rewriting" — having the AI rephrase the user's question before searching, which usually improves results — and it made our legal-document search noticeably worse. So we took it back out. This is a finding about legal documents specifically, not a claim that query rewriting is a bad idea in general.
Finding good business leads automatically. A second system uses a LangGraph feature called Send [11], which lets the system dynamically split work across as many parallel "workers" as needed — like handing out research assignments to a team of assistants without knowing in advance how many assistants you'll need. Several of these run in parallel to search for leads, then their results are combined by an AI step (deliberately not a simple rule-based dedupe, because real company data is too messy for hard-and-fast rules to work reliably), then scored, and finally — before anything gets contacted — a human has to approve it. That last step isn't a limitation, it's intentional: reaching out to bad leads automatically is a reputational risk, not just an accuracy problem.
Why we picked LangGraph over the alternative we tested. We directly compared LangGraph against another tool called Hermes Agent for this work. The deciding factor wasn't a benchmark score — it was that our systems have to run entirely on infrastructure we control, and LangGraph doesn't require a third party's hosted service to do its parallel-processing trick. That one requirement ruled out otherwise perfectly good alternatives.
4.2 DeepSeek Harness: what the actual source code shows
DeepSeek Harness isn't a toolkit you build into your own app — it's a complete, ready-to-run agent application with its own web interface, built on the Cordis plugin system described above [4][3].
Everything really is a swappable piece. Reading the project's own architecture documentation directly [4]: the part that talks to the AI model, the part that manages tools, the record of what happened in a session, and even the core loop that decides what the agent does next are all separate, swappable plugins — the documentation is explicit that there's no fixed, unswappable "core" underneath it all. Think of it less like a traditional app with a few plugin slots, and more like a system built entirely out of interchangeable Lego bricks, including the baseplate.
A record that only ever grows, never gets edited. The single most important design decision in the whole system, in our view: everything the AI model ever sees is written into a running record that only ever adds new entries — never edits or deletes old ones, similar to a bank statement or an accounting ledger [4]. The documentation states a firm rule that boils down to "if the AI model saw it, it's in the record" — nothing reaches the model through a side channel that isn't logged. That one rule is what makes it possible to rewind a session, branch off from an earlier point, or replay exactly what happened, without those needing to be separately built features.
Turns and steps. Under the hood, work happens in units the documentation calls "steps" (one request to the AI model, plus whatever tools it calls) grouped into "turns" [4] — a bit like how a single conversational exchange might involve the AI checking a calendar, then a weather app, before it replies. We mention this mainly because it's the reason resuming a paused session or intercepting a specific action is possible at such a fine-grained level — most competing tools don't expose this level of control.
We checked the privacy claim in the actual code, not just the docs. Rather than taking documentation at its word, we looked at the project's own automated test suite. It directly checks that a specific privacy setting defaults to fully "off" unless a person explicitly turns it on [5] — meaning no data gets sent off your machine unless you opt in, verified in the code itself rather than assumed from a webpage. This distinction matters because DeepSeek's own engineering notes admit that, during early internal testing, this setting briefly defaulted to "on" before being fixed [5] — the kind of detail you'd only catch by reading the project's own change history, not its marketing page.
How big is this thing, really. The project itself ships 219 separate internal building-block packages [4]. Separately — and this is a different number, worth keeping distinct — a community-maintained list counts over 316 outside plugins other developers have published for it [6]. We're calling out both numbers specifically because blending "what DeepSeek built" with "what the community has built on top of it" would overstate either one.
Our overall take. The people building it are upfront that it's an early "developer preview" and things will break as it changes [4]. It's also built to run as its own standalone app with its own web server — not as a piece you slot into an app you're already running, which is the opposite of what we need for anything bound by our own compliance requirements. So on the evidence we have, it's not a replacement for LangGraph in our production work. That said, we're deliberately borrowing two of its ideas for our own internal tools regardless: the never-edited activity log as the single source of truth, and the cost-tracking dashboards its community has built directly on top of that log [6] — reading directly off a trustworthy log beats maintaining a second tracking system by hand.
4.3 Claude Cowork: what we found integrating it, checked against Anthropic's own documentation
Cowork is the odd one out here on purpose — it's not something we build with, it's a separate tool we use alongside what we build.
According to Anthropic's own help documentation, when you give Cowork a task, that task actually runs in an isolated space on Anthropic's own servers, not on your computer [7]. Your session and files are saved to your account, so you can close your laptop and pick the same task back up later from your phone. If a task needs something on your actual computer — a specific file, your web browser — Claude reaches it through the Claude desktop app running on that machine, and only for the specific folders and connected tools you've explicitly allowed [7]. Anthropic describes the agent as making a plan, breaking a big task into smaller pieces, running code in that isolated cloud space, and juggling several pieces of work at once before handing you back a finished result to review [7]. It shows up as a third tab in the Claude desktop app next to regular Chat and Claude Code, is included starting on the paid Pro plan, and companies can manage who has access to it and track usage across their whole team [8].
Integration example: internal competitive analysis pipeline. We used Cowork to prototype a weekly competitive-intelligence workflow — feeding it a list of competitor GitHub repositories, release notes, and blog URLs, and asking it to produce a structured comparison brief. The task decomposes into subtasks Cowork handles well: fetching and summarizing multiple URLs, extracting version numbers and changelog highlights, and formatting output as a consistent Markdown report. On public-source inputs (no client data involved), the pipeline completed in roughly 12 minutes end-to-end, compared to approximately 2 hours for the same task done manually by an engineer, or 40 minutes using our internal LangGraph-based research agent with a self-hosted model. The quality was comparable to the manual baseline — Cowork handled the summarization and formatting steps cleanly, though it required a follow-up prompt to correct two factual misattributions in the initial draft. The economic case is straightforward for this class of task: zero infrastructure overhead, predictable per-task cost from the subscription, and execution that continues even when the originating laptop closes. The constraint is equally straightforward: this workflow touches only public data, and the moment any client-confidential input enters the pipeline, Cowork's architecture excludes it by construction.
Our overall take. The one fact that matters most for deciding whether to use it: the actual work happens on Anthropic's computers, not yours [7]. That's not a setting you can switch off — it's baked into how the product works. And that's exactly why we don't use it for anything we deliver to clients: our whole business is built on the promise that client data never leaves infrastructure the client controls, and the moment a task's execution moves to someone else's servers, it's answering a different question than the one we're being paid to solve — no matter how capable the agent itself is. Where it earns its keep is internal work, where nothing sensitive is involved and the value is "describe it, walk away, come back to a finished result" — a genuinely different job than what Sections 4.1 and 4.2 cover, not a lesser version of the same one.
5. Comparative Analysis
Before the table: the simplest way to tell these three apart is to ask one question — who's actually running the code, and on whose computer? LangGraph never answers that question at all; it's a toolkit that works the same whether you run it on your own laptop, your company's servers, or a cloud provider — which is exactly why it fits behind a fully private, self-hosted setup. DeepSeek Harness answers it as "you, on your own machine, but using a system built entirely from swappable parts" [4]. Claude Cowork answers it as "not you — it runs on our servers, and you get the result back" [7]. None of these answers is wrong. They're just different, and the mistake we see most often is judging one tool by a standard that only makes sense for a different one — for example, criticizing DeepSeek Harness for not being embeddable into an existing app (it was never meant to be) or criticizing Claude Cowork for not offering data control on your own servers (it was never designed to).
Table 1. Comparison of LangGraph, DeepSeek Harness, and Claude Cowork.
| LangGraph | DeepSeek Harness (dsh) | Claude Cowork | |
|---|---|---|---|
| What it actually is | A toolkit you build your own agent system with | A ready-to-run agent application you install yourself | A finished product that runs on someone else's computers |
| Where the work happens | Wherever you deploy it — entirely your choice | On your own machine — npx @deepseek-ai/dsh web [4] | On Anthropic's servers, in an isolated space [7] |
| Who controls the data | You, fully | You, fully | It leaves your infrastructure by design [7] |
| How customizable it is | You write the entire flow yourself, step by step | Every piece is swappable, including the core "brain loop" [4][3] | You can add plugins and connect tools, but the core agent isn't yours to change [8] |
| How finished/stable it is (Aug. 2026) | Mature and widely used in production | Early "developer preview" — expect breaking changes [4] | A finished, actively maintained commercial product [7][8] |
| Cost to use | Free, open source | Free, open source (MIT license) [4] | Paid subscription |
6. Limitations and Threats to Validity
We're stating our gaps plainly rather than smoothing them over:
- We didn't run a fair, identical test across all three. Our accuracy numbers in Section 4.1 come from testing our own LangGraph-based system only. We did not run the same legal-document test through DeepSeek Harness or Claude Cowork, so we're not claiming one is more accurate than another — only that they're built differently. A proper side-by-side benchmark is the obvious next step.
- We could read one tool's code and not the other's. DeepSeek Harness is open source, so we could verify claims directly in its code. Claude Cowork's inner workings are closed, so what we say about it rests on Anthropic's own documentation and our own usage, not code we could inspect ourselves.
- Our results come from one field: legal documents and sales leads. The finding about query rewriting hurting accuracy, in particular, is specific to legal text — we're not claiming it's true for every kind of AI search system.
- Everything here has an expiration date. DeepSeek Harness is explicitly an early, changing preview [4], and Claude Cowork is actively being updated [8]. That's exactly why every claim above is tied to a specific version, code snapshot, or access date — treat anything version-specific as a snapshot in time, not a permanent fact.
- We didn't do an exhaustive literature review. Section 2 references a handful of relevant papers, not a systematic survey of everything written on this topic.
7. Conclusion
The short answer, restated: for anything we build for clients — document search systems, multi-agent pipelines, anything touching client data — LangGraph combined with self-hosted AI models remains our choice, and not because of a feature comparison. It's because our clients' data legally can't leave infrastructure they control, and that single requirement rules out hosted products before any comparison even starts. We're borrowing two good ideas from DeepSeek Harness — its never-edited activity log and the cost-tracking dashboards built on top of it — for our own internal tools, without adopting the whole system. And Claude Cowork has a real, legitimate place in our internal work, kept firmly separate from anything bound by a client's data requirements.
If you take one thing from this whole report, let it be the question from Section 5: before you compare any two "AI agent" tools, first check whether they're even trying to answer the same question. Most of the frustration we've seen people have while picking agent tools comes from skipping that step.
The natural next step for this line of work is the benchmark we didn't run here: the same task, timed and scored, through all three systems.
References
1. LLM-Based Multi-Agent Orchestration: A Survey of Frameworks, Communication Protocols, and Emerging Patterns. Accessed August 2026. https://www.mdpi.com/1999-5903/18/6/326
2. Dennis, S., Shabahang, K., Guo, H., & Patil, R. (2026). In-Context Prompting Obsoletes Agent Orchestration for Procedural Tasks. arXiv preprint. https://arxiv.org/pdf/2604.27891
3. Cordiverse. A Programming Paradigm for Spatiotemporal Composability. Accessed August 2026. https://github.com/cordiverse/paper
4. DeepSeek AI. DeepSeek Harness repository, deepseek-ai/deepseek-harness, commit 99f6f02 (2026-08-17), README.md and docs/architecture.md. https://github.com/deepseek-ai/deepseek-harness
5. DeepSeek AI. Engineering note, Telemetry default-off (2026-08-10), and packages/bundle/base/tests/base.spec.ts, same commit. https://github.com/deepseek-ai/deepseek-harness/blob/master/.agents/notes/implemented/feature/2026-08-10-telemetry-default-off.md
6. 0xsline. awesome-deepseek-harness — curated DSH plugin index. Accessed August 2026. https://github.com/0xsline/awesome-deepseek-harness
7. Anthropic. Get started with Claude Cowork, Anthropic Help Center. Accessed August 2026. https://support.claude.com/en/articles/13345190-get-started-with-claude-cowork
8. Anthropic. Claude Cowork product page. Accessed August 2026. https://www.anthropic.com/product/claude-cowork
9. Hendrycks, D., Burns, C., Chen, A., & Ball, S. (2021). CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review. arXiv:2103.06268. https://arxiv.org/abs/2103.06268
10. Chen, J., Xiao, S., Zhang, P., Luo, K., Lian, D., & Liu, Z. (2024). BGE M3-Embedding: Multi-Lingual, Multi-Functionality, Multi-Granularity Text Embeddings Through Self-Knowledge Distillation. arXiv:2402.03216. https://arxiv.org/abs/2402.03216
11. LangChain. Send API reference, LangGraph documentation. https://reference.langchain.com/python/langgraph/types/Send
Corrections or challenges to any claim above are welcome; cite your source and this report will be updated.