One-line summary: DeepSeek Harness gives you a runtime system you can rework; Codex offers both an open-source core and an official product; Claude Code delivers capability through commercial tooling and extension interfaces. The real difference is which layer you’re allowed to modify — and who maintains it once you do.
The framing that “DeepSeek Harness is open source, while Codex and Claude Code are closed-source finished products” doesn’t really hold up. Based on the official materials provided, with a verification date of November 12, 2026, Codex CLI is licensed under Apache-2.0, and OpenAI has also published Codex Harness — but model access and hosted cloud services sit on different layers.
This article won’t give you an efficiency ranking without any measurements behind it. Instead, it puts all three options into a single task: gather AI news every day, generate topic ideas and research bundles, then save the draft to the company backend. Following that task, we’ll walk through the differences layer by layer — source code, tooling, execution environment, and maintenance responsibility.
Understanding DeepSeek Harness, Codex, and Claude Code: put the terminology back into the task
An Agent isn’t just a model that answers questions. To have it search the news, call a browser, and save a draft, you also need a system that organizes the model, tools, state, and execution process. That’s an Agent Harness.
Think of the model as the “brain” that proposes the next action, and the Harness as the part that turns that action into a real tool call and sends the result back to the model. Between the two sit permissions and an execution environment — so “connecting to a model API” doesn’t mean “a complete Agent is ready to use.”
| Term | Meaning in a news-topic task | Common point of confusion |
|---|---|---|
| Agent Loop | The loop of searching, reading results, verifying further, and then generating a draft | It’s not a single model request |
| Model adapter | Converts requests into the format the model service expects | A configurable endpoint doesn’t mean full protocol compatibility |
| MCP | A protocol for connecting to search, databases, or internal company tools | Connecting a tool doesn’t mean you automatically get business permissions |
| Sandbox | The execution environment that restricts command, file, and network access | The isolation effect depends on the configuration |
| Open-source license | Sets the conditions for using, modifying, and distributing public code | It doesn’t include free use of model services or cloud resources |
MIT and Apache-2.0 are both permissive open-source licenses that allow use, modification, and distribution, but you still have to follow their respective conditions. “Developer preview” means the product is still at an early stage, and interfaces, plugins, and compatibility may change — it shouldn’t be read as already suitable for production deployment.
How Open Is the Source Code for DeepSeek Harness, Codex, and Claude Code, Really?
First, let’s clear up the core misconception: Codex can’t be broadly described as a closed-source product. The public source code for Codex CLI uses the Apache-2.0 license, and OpenAI’s public Harness also provides an entry point for researching and integrating underlying Agent systems. That’s a different matter from buying the official hosted service.
| Comparison | Scope of openness | How you can use it | What you shouldn’t conclude |
|---|---|---|---|
| DeepSeek Harness | A public project open-sourced under MIT | Inspect, modify, and extend the runtime system | That it’s already been security-audited and needs no maintenance |
| Codex CLI / Harness | CLI is Apache-2.0; Harness is public | Modify public code and integrate Agent capabilities | That cloud services, models, and infrastructure are all open source |
| Claude Code | A commercial, closed-source product with extension interfaces | Customize through tools, Hooks, and subagents | That you can freely modify its non-public internal engine |
DeepSeek Harness is closer to an Agent runtime system that developers can modify. The official offering includes Web, Headless, SDK, a slim SDK, and ACP runtime configurations, so you can pick the interaction mode your app needs instead of being locked into a fixed interface.
Codex spans two tracks: an open-source core and a ready-to-use product. Developers can integrate tasks, sessions, events, and approval flows through the SDK, App Server, or codex exec, while regular users can use the official CLI, App, IDE, or Cloud product.
Claude Code, meanwhile, puts the emphasis on a development tool you can use right away and official extension mechanisms. It’s not that it can’t be customized at all—it’s that customization usually happens at the level of tools, events, and task division. But that doesn’t mean the underlying execution engine is open.
DeepSeek Harness, Codex, and Claude Code: 5 Dimensions of Control
When you’re judging control, don’t just ask “does it have plugins?” The more useful question is: when your news workflow breaks, can you change how models are connected, how tools behave, how the loop is structured, how sessions are recovered, and the actual runtime environment?
| Control dimension | DeepSeek Harness | Codex | Claude Code |
|---|---|---|---|
| Model access | Replaceable model adapters, though the protocol needs verification | Public code can be studied, but the official product is still bound by its model access rules | Supports the service connection methods listed by the official docs — which doesn’t mean any model can be swapped in |
| Tool extension | Tool registry and execution components can be modified | Supports MCP, Hooks, Skills, Plugins, and more | Supports MCP, Hooks, Skills, Plugins, and more |
| Agent Loop | The core loop can be reworked through plugins or source code | The public harness can be modified; hosted services have their own boundaries | Extensions can influence the flow, but you can’t freely modify an unpublished engine |
| Sessions and state | Logging, storage, and recovery can be swapped out | The App Server and similar components provide session and event integration | Workflows can be managed through official interfaces and subagents |
| Execution environment | You configure files, Shell, sandbox, and background tasks yourself | Can run locally, or use the official cloud environment | Depends on the product entry point, execution mode, and authorization |
DeepSeek Harness: you can change how the workflow runs
DeepSeek Harness’s architecture leans hard on the idea that “Everything is a Plugin.” Model adapters, tool registries, session logs, the Agent Loop, the file system, command execution, sandboxing, and approval policies can all be replaced through plugins and configuration.
Say, for example, a team requires that “every story must have multiple independent sources, otherwise it can’t be saved.” Developers can fold verification tools and enforcement policies into the system flow. But being able to modify the source code is only a precondition for implementation — whether the rule actually holds up still takes testing and review. You can’t guarantee it with a prompt alone.
Codex: public code and the official service are two different scopes of control
Codex’s advantage is that you can use the public runtime code, or opt for the official product experience. If you’re embedding its capabilities into company software, the SDK, App Server, and script execution entry points offer different ways to integrate. If you use Codex Cloud, the remote compute environment is managed by OpenAI.
That means editing the public code locally doesn’t mean you can modify the official cloud service. And just because an official cloud task keeps running after your laptop sleeps doesn’t mean it can reach files on a powered-down machine or your existing browser login state.
Claude Code: extending the workflow isn’t the same as rewriting the engine
Claude Code’s MCP can connect to databases and business services, and Hooks can run checks before or after tool calls, on permission requests, or when a task finishes. Subagents can have their own context, prompt, tool permissions, and model selection, which is handy for splitting research from source verification.
For a news workflow, you could design a “validate before saving” Hook and then create drafts through a background tool. That’s influencing execution through extension interfaces, not modifying the internal Agent Loop. And per-agent model selection doesn’t mean every product interface lets you plug in any model service.
The diagram makes a distinction worth keeping straight: model connectivity versus the execution system. APIYI (apiyi.com) can be a candidate platform for model API access, but it can’t replace each tool’s own runtime environment, permission configuration, and product rules.
Self-Hosting DeepSeek Harness: What Maintenance Responsibilities Do You Actually Take On?
Open source doesn’t mean zero cost. Beyond model invocation, a news workflow also needs search services, a browser, storage, login credentials, a continuously running environment, and retry and troubleshooting mechanisms for when things fail.
| Responsibility | Self-Hosted DeepSeek Harness | Codex Route | Claude Code Route |
|---|---|---|---|
| Model and tool costs | Configure and account for them yourself | Varies with the API, product, and cloud task approach | Varies with the API, product, and extension tool approach |
| Continuous runtime environment | Deploy, monitor, and recover it yourself | You maintain it locally; official Cloud manages remote environments | You need to confirm the specific runtime entry point and remote requirements |
| Browser and login | Install the provider, manage sessions and credentials | Configure and verify based on your actual environment | Configure and verify based on the browser integration method |
| Security and upgrades | Responsible for components, isolation, approvals, and compatibility | After modifying public code, you maintain your own version | Maintain extensions, authorization, and upgrade compatibility |
| Candidate entry points for model APIs | APIYI apiyi.com — verify the adapter first | Not the same as getting official product subscription entitlements | Not the same as being compatible with any entry point |
Browser operations in DeepSeek Harness aren’t all ready out of the box. The official docs require installing dsh-browser-use and explicitly enabling an experimental provider such as Playwright MCP, Chrome DevTools MCP, or Stagehand.
Browser login state isn’t automatically restored from session logs; reloading or forking a session creates a new browser state. Actions that have already been sent can’t be undone by canceling the task either. So a production back office should distinguish between “generate draft,” “save draft,” and “publish content” — don’t treat the cancel button as a business rollback mechanism.
Security limits matter especially here: the official docs label DeepSeek Harness as a developer preview and state clearly that it hasn’t completed a security audit and shouldn’t be considered production-ready security. Use least privilege and disposable VMs, containers, or dedicated environments — don’t treat the built-in sandbox as your only line of defense when running untrusted tasks.
How Do DeepSeek Harness, Codex, and Claude Code Verify Model Access First?
Validate the model API first, then agent tool invocation, and finally backend persistence — that’s the order that makes debugging easier. The two examples below are only model connection tests; they’re not the full installation and configuration for these three agents, and they don’t prove that just any client will be compatible out of the box.
A Minimal Model Connection Test for DeepSeek Harness, Codex, and Claude Code
The model identifier in your environment variables should use the name currently available on the platform, and never put your key into code or logs. The examples assume the runtime already has the OpenAI Python SDK installed.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["AI_API_KEY"],
base_url="https://api.apiyi.com/v1",
)
response = client.chat.completions.create(
model=os.environ["AI_MODEL"],
messages=[{"role": "user", "content": "列出新闻来源核查步骤。"}],
)
print(response.choices[0].message.content)
Checking the Tool-Calling Protocol for DeepSeek Harness, Codex, and Claude Code
Once plain text works, check whether the model returns a valid tool call, then move on to testing tool execution, result passing back, and the second-round response. The example below only inspects the structure of the first response — it doesn’t actually touch any company backend.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["AI_API_KEY"],
base_url="https://api.apiyi.com/v1",
)
response = client.chat.completions.create(
model=os.environ["AI_MODEL"],
messages=[{
"role": "user",
"content": "请调用 check_source 检查输入的新闻来源。",
}],
tools=[{
"type": "function",
"function": {
"name": "check_source",
"description": "Check a news source without changing data.",
"parameters": {
"type": "object",
"properties": {"source": {"type": "string"}},
"required": ["source"],
},
},
}],
)
message = response.choices[0].message
print("tool_calls:", message.tool_calls)
print("content:", message.content)
Even if a tool call comes back, you still need to check argument parsing, error handling, streaming events, and context recovery. The fact that the DeepSeek adapter supports a custom Base URL doesn’t mean just any service meets that adapter’s expectations; Codex and Claude Code also need to be validated against their own protocol and configuration requirements.
Quick verification tip: According to the platform’s public description, APIYI apiyi.com offers an OpenAI-compatible interface where a single API key connects you to mainstream models like OpenAI, Claude, and Gemini. It uses pay-as-you-go billing, and the platform mentions discount pricing as well as free trial credits for new users. Specific models, promotions, and compatibility should be based on the current documentation and actual requests — model API access does not include Codex Cloud or Claude Code product subscriptions.
What Scenarios Are DeepSeek Harness, Codex, and Claude Code Each Best Suited For?
If you need to change “when to keep searching, when to refuse to save, and how to resume an interrupted session,” study DeepSeek Harness first. It provides deeper control over runtime mechanics, but your team should be able to handle deployment, security, and version maintenance.
If you want to use open-source code while keeping the official product and cloud task options, study Codex first. Decide upfront whether you’ll use the local CLI, SDK integration, or Cloud, so you can accurately determine which components you’ll maintain yourself.
If your goal is to get a coding Agent up and running quickly and connect it to company workflows through MCP, Hooks, and Subagents, study Claude Code first. The prerequisite is that the official extension interfaces cover your needs—not that you have to rewrite the underlying loop.
For practical trials, use the same set of acceptance criteria rather than comparing the number of features:
- Source verification: When the source cannot be confirmed, can it stop and explain why?
- Permission control: Can it read test data but not publish production content?
- Interruption recovery: After a restart, can it recognize a saved draft and avoid duplicate submissions?
- Failure handling: When a backend button changes or a tool times out, does it leave a record you can use to locate the issue?
These are suggested test items, not tests already completed in this article. Total cost should also include manual troubleshooting, upgrades, and recovery time, not just model tokens or subscription fees.
DeepSeek Harness, Codex, and Claude Code: Common Questions
Codex is open source now — can you use all its cloud capabilities for free?
No, that’s not a safe assumption. The source code license for Codex CLI/Harness is a separate layer from model access, remote compute, and hosted services. And the model API access that APIYI apiyi.com provides doesn’t equal Codex Cloud entitlements either.
Can DeepSeek Harness hook up to any model just by changing the Base URL?
Not guaranteed. APIYI apiyi.com’s unified interface can be used for connection testing with candidate models, but you still need to verify adapter protocols, tool calls, streaming output, and error handling. A successful text response doesn’t prove full Agent compatibility.
Claude Code has Hooks — does that mean the engine is open source?
No. Hooks are officially exposed execution node interfaces that let you inspect or influence the flow, but that’s not the same as being able to view and modify internal loops that haven’t been made public.
Can DeepSeek Harness go straight into production?
You shouldn’t decide that based on open source alone. The official docs explicitly state it hasn’t completed a security audit yet, so you should start with isolated environments, least privilege, and recoverable testing workflows.
Can Codex Cloud keep a task running after your local machine shuts down?
Official materials say cloud tasks can keep running. But the cloud still needs its own code, dependencies, network access, and authorization — it can’t directly control a local computer that’s already powered off.
Which of the three finishes a news-topic-selection task the fastest?
This article doesn’t have benchmark results from running the same task, so I can’t give a speed or success-rate ranking. You should record completion status, human intervention, and actual cost under identical inputs, permissions, and acceptance criteria.
Key Takeaways for DeepSeek Harness, Codex, and Claude Code
- Source code openness: Codex can’t simply be classified as a closed-source product.
- Depth of control: Plugin interfaces and changes to the underlying loop aren’t the same thing.
- Operational responsibility: Self-hosting means you’re responsible for deployment, recovery, and upgrades.
- Model boundaries: API connectivity doesn’t equal full Agent compatibility.
- Security boundaries: DeepSeek Harness is still an unaudited developer preview.
- What to base your choice on: Compare actual acceptance results—don’t use feature count as a substitute for efficiency.
Summary: How should you choose between DeepSeek Harness, Codex, and Claude Code?
If you need to control the underlying runtime mechanism, look into DeepSeek Harness. If you need both an open-source code path and an official product path, look into Codex. If you want to use a development tool directly and customize it through extensions, look into Claude Code. These are need-based selection criteria, not an overall ranking of strengths and weaknesses.
We recommend first verifying candidate model connectivity and tool calls through APIYI apiyi.com, then separately testing the Agent’s permissions, browser, and recovery mechanisms. Open-source availability, ease of use, and final work efficiency are three dimensions that can’t substitute for each other.
DeepSeek Harness, Codex, and Claude Code Reference Materials
Below are the official sources listed in the materials provided by the user. The verification date is November 12, 2026. Online content, entry points, and account requirements may change by version; this article does not include standardized task testing.
-
DeepSeek Harness official repository:
github.com/deepseek-ai/deepseek-harness
Includes the license, architecture, browser configuration, and security notes. -
Codex official repository:
github.com/openai/codex
For learning about the public CLI code and the Apache-2.0 license. -
Codex open-source Harness documentation:
developers.openai.com/blog/codex-as-a-platform
Clarifies the difference between the open runtime system, integration entry points, and hosted services. -
Codex Cloud documentation:
help.openai.com/en/articles/20001545-using-codex-cloud
Introduces the official remote execution environment and the boundaries of task execution. -
Claude Code official documentation:
code.claude.com/docs/en/overview
MCP, Hooks, Subagents, and service access requirements are governed by the corresponding documentation.
Author: APIYI Technical Team
Technical discussion: We welcome discussion through APIYI at apiyi.com on model adaptation, tool calling, and Agent integration. When troubleshooting, please provide sanitized configuration and error information; do not submit real keys or backend credentials.
