# DeepSeek Harness: el harness abierto que hace lo que Claude Code no te deja tocar

> Source: <https://dev.to/macorreag/deepseek-harness-el-harness-abierto-que-hace-lo-que-claude-code-no-te-deja-tocar-2df4>
> Published: 2026-09-02 01:19:18+00:00

Los agentes de código son todavía una tecnología relativamente nueva. Y aun así, casi todos venimos de la misma experiencia: abres Claude Code (o cualquier otro), le pides algo, y en el momento en que algo sale mal… estás mirando una caja negra.

Si alguna vez te hiciste esas preguntas, este post es para ti. Porque **DeepSeek Harness** responde las cuatro — y la última de una forma que va a cambiar cómo piensas lo que un "harness de agentes" puede ser.

Spoiler: no es "otro Claude Code". Es otra categoría. Y es

open source(MIT).

DeepSeek Harness (`dsh`

) es un **harness de agentes basado en plugins**. No es una app monolítica: es un runtime sobre **Cordis**, un framework de plugins, donde *absolutamente todo* es un plugin:

Se arranca igual de fácil que cualquier CLI:

```
dsh web                            # interfaz web completa
dsh --profile headless "corre los tests"   # one-shot, headless
dsh --profile <mi-perfil>          # tu propio perfil
```

Lo importante no es *cómo se arranca*, sino lo que esa arquitectura te permite hacer. Vamos a ello.

Esta es, para mí, la killer feature. Y la razón por la que lo llamo "disruptivo" sin exagerar.

DeepSeek Harness tiene una vista llamada **Trajectory**: un *ledger* de eventos por turno donde puedes seleccionar registros de **User**, **Assistant**, **Tool** y **Subtool** anidados. Por cada evento ves:

Traducción práctica: cuando un run se descarrila, no adivinas. **Sigues la traza** y ves si el problema fue un tool que devolvió basura, un turno del modelo que alucinó, o tu prompt que estaba mal formulado. La responsabilidad queda *atribuida*, no diluida.

Y esto no es solo cosmética: los errores son **estructurados y legibles**. Cuando algo se bloquea, el harness no te suelta un stderr críptico. Te dice exactamente qué pasó:

```
[exit code: 1]
[sandbox: file access denied under workspace-write mode]
[status: running]  →  [status: complete]
```

Ese último patrón es clave para lo que viene. Porque una denegación no es un muro: es **información accionable**.

Aquí es donde mucha gente se equivoca con los agentes. Piensan que "seguro" significa "capado". DeepSeek Harness demuestra lo contrario.

Puedes **endurecerlo** tanto como quieras:

`read-only`

, `workspace-write`

y `danger-full-access`

. El agente arranca confinado al workspace y a los directorios temporales, y `ask`

Lo brutal es que, **dentro de ese régimen endurecido, el agente sigue logrando las cosas**. ¿Por qué? Porque la denegación es *legible y recuperable*: el agente ve el marcador `[sandbox: file access denied under workspace-write mode]`

, entiende exactamente qué pidió y qué se le negó, y pide *un único* reintento con el modo más amplio justo y necesario — no abre la compuerta entera.

Es la diferencia entre "caja negra que a veces se atasca" y "sistema confinado que te explica qué necesita y por qué". Para una empresa, eso es **auditabilidad**. Y la auditabilidad es lo que te deja dormir tranquilo.

Esto es lo que Claude Code literalmente **no te deja tocar**. La UI de DeepSeek Harness también es un conjunto de plugins (`client-ui-*`

): tema, layout, sidebar, renderer de mensajes, marca, ajustes, todo.

¿Qué significa en la práctica?

Piénsalo en términos de producto: con Claude Code estás *dentro* de la experiencia que Anthropic decidió darte. Con DeepSeek Harness, **la experiencia es tuya**. Para una startup que quiere vender un agente embebido o una herramienta interna, esto no es un detalle: es la diferencia entre "usar una app" y "construir sobre una plataforma".

Otra cosa que aquí es *core* y en otros sitios es un parche:

`subagent`

y `subagent_fork`

): delegación con o sin herencia de contexto, en background, y con control (`send_message`

, `interrupt`

).Traducción: el *fan-out*, la persistencia de objetivos y la iteración multiagente no son hacks. Son herramientas del propio harness.

La agnosticidad de modelo no la voy a vender como novedad — Codex ya lo hacía —; aquí simplemente **se mantiene**. Lo que sí vale la pena para una empresa es lo demás: lo corres **self-host** (tus datos, tus llaves, tus logs) y controlas costes con **medidor de tokens** y **compactación** configurables.

Hay una consecuencia del diseño por plugins que pocos notan, y para mí es de las más importantes: **las skills hoy están secuestradas por cada proveedor**.

DeepSeek Harness tiene su propio sistema de skills (`dsh-skill`

), pero lo clave es que, como *todo* es un plugin, **puedes escribir un plugin que interprete los formatos de skills de otros proveedores** — Claude Skills, Codex, o los que vengan — y los exponga como skills nativas dentro del mismo harness.

Traducción: tu inversión en skills deja de estar presa de un vendor. Un plugin, y tienes **una sola** librería de skills, agnóstica de formato, corriendo sobre el modelo que tú elijas. Eso es algo *impensable* en Claude Code o Codex: son productos cerrados, y ni siquiera tienen un punto de extensión donde enchufar un intérprete de skills ajeno.

DeepSeek Harness |
Claude Code |
|
|---|---|---|
| Arquitectura | 100% plugins (Cordis): tools, loop, UI, sandbox | Monolito cerrado |
| Modelo | Agnóstico (se mantiene; Codex ya lo hacía) | Atado a Claude |
| Observabilidad | Trajectory: User/Tool/Assistant/Subtool, timing TTFT vs decoding, tokens por evento | Caja negra |
| UI | Plugins tematizables + re-branding + HMR en vivo | Fija, no se toca |
| Sandbox | Modos por call + bash a nivel kernel + approval `ask`
|
Limitado |
| Orquestación | Goals, Workflows, Ralph, subagentes | Mínima |
| Extensión | Escribes tus propios plugins y perfiles | No extensible |
| Skills | Plugin compatible multi-formato (Claude, Codex, propios) | Atadas a cada proveedor |
| Hosting | Self-host, auditable | SaaS |

La diferencia de fondo no es "tiene más features". Es una cuestión de **filosofía**: Claude Code es un producto cerrado que *te deja usar*. DeepSeek Harness es una plataforma abierta que *te deja construir*.

Para una startup, esto es la diferencia entre alquilar una herramienta y poseer una ventaja competitiva. Para una empresa, es la diferencia entre "adoptar una IA opaca" y "gobernar una IA auditada".

DeepSeek Harness todavía está en release candidate (`0.1.x`

), y no te voy a vender que es perfecto. Pero su apuesta arquitectónica es la correcta: **abierto, observable, endurecible y re-brandeable**. Es exactamente lo que un harness de agentes *debería* ser en 2026, y lo que los productos cerrados no pueden —ni quieren— ofrecerte.

Si estás construyendo algo con agentes, hazte una pregunta honesta: ¿quieres estar *dentro* de la caja negra de otro, o quieres una caja que puedas abrir, auditar y hacer tuya?

Yo ya elegí. 🚀

*¿Has probado DeepSeek Harness? ¿O vienes de la frustración de no poder tocar tu agente actual? Cuéntamelo en los comentarios.*
