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

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.

• ¿Por qué falló?
• ¿Fue el tool? ¿Fue el modelo? ¿Fue tu prompt?
• ¿En qué turno exacto se torció todo?
• ¿Y por qué no puedo cambiarle ni el color a esta interfaz?

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

Qué es DeepSeek Harness

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:

• las tools (bash, filesystem, search, web, ask-user, skills…)
• el loop del agente y el sistema de goals
• el sandbox y la política de permisos
• la UI del navegador (tema, layout, sidebar, renderer, marca)
• la orquestación (workflows, subagentes, Ralph)
• hasta el medidor de tokens y la compactación de contexto

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.

1. Observabilidad: sabes exactamente dónde falló (tool, modelo o usuario)

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:

• timing real: cuánto fue TTFT (time-to-first-token) y cuánto fue decoding (con hover para el reloj exacto)
• tokens consumidos por evento
• input / output completo de cada tool call
• las fronteras de turno y de step bien marcadas

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.

2. Hardened de verdad: sandbox duro, y aun así no te frena

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:

• Sandbox por modos, en cada call: read-only, workspace-write y danger-full-access. El agente arranca confinado al workspace y a los directorios temporales, y nada más.
• Sandbox de bash a nivel kernel (Seatbelt / Landlock), no solo una validación en el proceso.
• Política de aprobación ask: los permisos sensibles piden confirmación humana, con presets de permisos configurables.
• Skills limitantes: instrucciones reutilizables que puedes cargar para acotar el comportamiento del agente (sus reglas, sus límites, su “personalidad” operativa).

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.

3. Intervenir en el “look” del Agent (sí, de verdad)

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?

• Re-branding total: ¿quieres que el agente se llame como tu producto y lleve tus colores? Se puede. Es un plugin de UI, no un “dark mode”.
• Tematización y layout a tu gusto, no al del vendor.
• HMR en vivo del client-plugin: editas el plugin de UI y el navegador se recarga sin refresh. Cambias el look del agente mientras lo usas.

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

4. Orquestación multiagente de primera clase (no es un afterthought)

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

• Goals: un objetivo de larga duración event-sourced que persiste en la sesión y permite que el agente continúe de forma autónoma entre rondas (con un cap de rondas configurable). El estado se guarda como eventos en el log de sesión, así que es rejugable y auditable.
• Workflow tool: escribes un script JavaScript que fanea el trabajo a decenas de subagentes, con fases y resultados estructurados. Orquestación real a escala.
• Ralph: un loop de agentes frescos (cada ronda abre un agente nuevo sin semilla de conversación, usando el workspace como memoria). Ideal para iteración que no quiere arrastrar sesgo de contexto.
• Subagentes (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.

5. Self-host: tus datos, tus reglas

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.

6. Skills desatadas del proveedor: un plugin para gobernarlas a todas

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.

• Las Claude Skills solo viven dentro de Claude Code.
• Las skills de Codex solo viven dentro de Codex.
• ¿Cambias de agente? Pierdes (o tienes que reescribir) toda tu librería de skills.

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.

La comparación (sin dramatismo)

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.

Por qué es el mejor harness para compañías y startups

1. Auditable: sabes qué tool falló, qué modelo se equivocó, qué pidió el usuario. La traza está ahí, atribuida.
2. Endurecible: sandbox duro + approval, sin sacrificar productividad. Seguridad que no frena.
3. Personalizable: re-brandea la UI, escribe tus propios tools/skills/plugins. Tu producto, no el del vendor.
4. Composable: orquestación multiagente como primitiva de primera clase.
5. Portable: tus skills no quedan atadas a un proveedor; un plugin las unifica (Claude, Codex, propios).
6. Controlable: self-host + medidor de tokens = dueño de tus costes y tus datos.

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

El punto

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.