KuroCode

Gratis durante la beta

Tu equipo decide. El agente lo hace.

KuroCode es donde un proyecto se analiza, se decide y se construye. Cerrar el análisis es lo que autoriza el trabajo — el mismo documento en el que escribe tu equipo se convierte en el plan que el agente ejecuta, tarea a tarea.

Descargar para Mac · Apple Silicon

Versión 1.2.25

Windows · Instalador (x64)Linux · AppImage (x64)Linux · AppImage (ARM)

Firmada y notarizada por Apple, así que abre sin ningún aviso.

Los tres sistemas, desde el primer día.

Transcripción de la sesión
invoice-apifeat/json-exportsesión · qwen3-coder:30b
  1. ›Este es el plan: un flag --json en export, sus tests, y retirar el viejo --format.
  2. Leyendo el repositorio. Tres tareas, y no todas necesitan el mismo modelo.
  3. Plan · 3 tareas

    1. 1Añadir el flag --jsoncoderqwen3-coder:30blocal
    2. 2Tests de las dos formascoderqwen3-coder:30blocal
    3. 3Retirar --format sin romper a quien lo usaarchitectclaude-sonnetnube
  4. codereditsrc/cli/export.ts+18 −4
  5. coderedittest/export.test.ts+26
  6. Dos tareas hechas. La tercera quiere la suite en verde antes de tocar el flag viejo.

    ¿Ejecuto este comando?

    architectrunpnpm test export

  7. architectrunpnpm test export
  8. 14 pasados en 2,3 s
  9. Dos de las tres tareas se hicieron con el modelo de tu propia máquina. Solo la migración fue al de la nube.
  10. Parado. El comando no llegó a ejecutarse ni se abrió ningún proceso.
  11. De eso va todo esto: el plan propone, tú decides dónde se para.

Pruébalo: el agente está esperando permiso.

plan

El proyecto empieza con una decisión, no con un prompt.

Un proyecto guarda la idea, el análisis y el plan en un mismo documento. Cerrar el análisis es lo que autoriza el trabajo: el plan que sale de ahí es un contrato, no una sugerencia que el agente pueda reinterpretar.

  • Un documento, no un chat y un ticket aparte

    La idea, lo que se decidió y la lista de tareas que sale de ahí viven juntas — no repartidas entre una conversación que nadie vuelve a leer y un ticket que no cuenta el porqué.

  • Cerrar el análisis autoriza el trabajo

    Nada se ejecuta desde una pregunta abierta. El plan solo existe una vez que el análisis del que sale está cerrado.

  • Replanifica cuando la realidad no coincide

    Si lo que se encuentra no cuadra con el plan, reescribe el resto de la lista — y guarda el historial de lo que cambió, para que veas qué decidió y por qué.

equipo

Un documento, dos tipos de autor.

Un proyecto lo escriben personas y agentes en la misma página. Cada aportación lleva quién la hizo — alguien del equipo, o un perfil con su propio modelo — y cuándo. En cuanto el equipo cierra el análisis, eso es lo que el agente ejecuta.

  • Personas y agentes, mismo documento

    La idea, el análisis y la lista de tareas viven en un mismo sitio, sea quien sea quien las escribió.

  • Cada aportación va firmada

    Nombre, modelo — cuando es de un agente — y fecha, en todo, así que siempre puedes ver quién decidió qué y cuándo.

  • Lo delegado rinde cuentas

    Una tarea que se le pasa a un agente corre en segundo plano y vuelve con qué hizo, cuánto tardó, qué herramientas usó y qué costó.

coste

El modelo caro solo donde se lo gana.

Casi todo un día de trabajo es faena barata: lee este fichero, renombra aquello, escribe el test calcado del de al lado. Pagarlo todo a precio de nube es la razón de que la factura sea la que es.

  • Lo rutinario, al modelo local

    Un modelo de código en tu propio hardware te cuesta electricidad. Da de sobra para la mitad rutinaria de un plan, y esa mitad no sale de tu escritorio.

  • Lo difícil, al bueno

    La decisión de diseño, la migración fea, el bug que no entiende nadie — eso va a un modelo de la nube, y solo eso.

  • La mezcla es por agente, no por sesión

    El modelo es parte del perfil, así que un mismo plan puede correr contra tres modelos distintos sin que tú cambies nada a mitad.

El gasto por día, por modelo y por proyecto está en Configuración, así que lo que ha costado un proyecto — y lo que costará el siguiente — es un número que puedes leer, no una promesa nuestra.

permisos

Cada herramienta espera tu visto bueno.

El agente lee ficheros, busca en el árbol, edita, aplica parches, ejecuta comandos y descarga URLs. Qué puede hacer sin preguntar lo decides tú, y se cambia a mitad de sesión.

Preguntar
Cada edición y cada comando se paran a pedir permiso. Es el modo por defecto, y el que quieres en un repositorio que te importa.
Edición automática
Las ediciones de ficheros pasan solas; los comandos de shell siguen esperando. Va bien para un plan largo que estás mirando.
Sin frenos
No se para nada. Para un worktree de usar y tirar donde lo peor que puede pasar es un `git checkout .`.

También hay un modo plan: el agente investiga y escribe lo que pretende hacer, sin tocar un solo fichero.

privacidad

Qué sabemos de ti, y qué no.

KuroCode te pide entrar con contraseña o con Google. Lo que esa cuenta guarda se lee de una sentada.

Qué guarda la cuenta

  • Tu dirección de correo
  • Tu nombre, apellido y país
  • Un identificador de cuenta
  • El día que te diste de alta y el último que abriste la app

Dónde va tu código

  • A tu repositorio, cuando haces push
  • Al modelo que elijas; si es local, no sale de tu máquina
  • A nosotros, nunca — en nuestros servidores solo está tu cuenta

Tu código y tus prompts solo salen hacia el endpoint del modelo que tú configures: apúntala a Ollama en localhost y no cruzan ni la tarjeta de red; añade una clave de la nube y los prompts de las tareas que vayan ahí llegan a ese proveedor, como con cualquier otro cliente. Aparte de eso, la app habla con nosotros para comprobar que tu sesión sigue valiendo y para mirar si hay una versión nueva. Nada más.

de qué va esto

Esto no es otro asistente.

Los agentes de código hacen el trabajo, pero nada sobrevive al prompt. Los gestores de proyecto lo gestionan, pero el ticket solo lo describe — el trabajo pasa en otro sitio. Lo que cambia aquí es cuál de las dos cosas te llevas, y si te llevas las dos.

KuroCode

lo hace y lo gestiona

Qué es
Su propia app de escritorio: el análisis compartido, el plan y el agente que lo ejecuta, en el mismo documento.
Unidad de trabajo
Un proyecto: un análisis que el equipo cierra junto se convierte en un plan de tareas.
Quién lo escribe
Tu equipo — con nombre, modelo y fecha en cada aportación, sea de una persona o de un agente.
Quién lo ejecuta
El agente, tarea a tarea, contra el plan que el equipo acaba de cerrar.
Qué sobrevive
Todo el rastro de la decisión: quién propuso qué, cuándo se cerró, qué costó.
Tu código
Se queda en tu máquina, dirigido al modelo que tú elijas.

Claude Code · Cursor · Copilot

lo hace

Qué es
Una sesión de terminal o de editor, dentro de la herramienta que ya tienes abierta.
Unidad de trabajo
Un prompt. Lo que pediste vive en el scroll hacia arriba.
Quién lo escribe
Quien esté escribiendo, un prompt cada vez.
Quién lo ejecuta
El agente — pero solo para esa sesión.
Qué sobrevive
Nada: cierras la pestaña y el razonamiento desaparece.
Tu código
Va al modelo que ese proveedor ponga detrás.

Jira · Linear · Notion

lo gestiona

Qué es
Un tablero o un documento, separado de donde pasa el trabajo de verdad.
Unidad de trabajo
Un ticket: un título, una descripción, un estado que actualizas a mano.
Quién lo escribe
Quien escribe el ticket.
Quién lo ejecuta
Nadie — una persona o un agente, en otro sitio, hace lo que el ticket describe.
Qué sobrevive
El ticket en sí, pero no el razonamiento que lo cerró.
Tu código
No aplica — el código nunca pasa por estas herramientas.

Léelo como qué se le da bien a cada herramienta, no como un marcador. Todas se mueven rápido; si algo de aquí se ha quedado viejo, escríbenos y se corrige.

modelos

Trae tu propio modelo.

Apunta KuroCode a lo que ya tengas corriendo. Un endpoint local es lo que hace gratis la mitad barata del plan; una clave de la nube es lo que hace buena la mitad difícil.

  • OllamaLocal
  • LM StudioLocal
  • DeepSeekClave de API
  • Compatible con OpenAICualquier endpoint
  • AnthropicClave de API
  • OpenAIClave de API
  • Google GeminiClave de API
  • GLM · Z.AIClave de API
  • SuscripcionesSin clave de API

Y unos sesenta proveedores más en el catálogo, elegidos por su nombre. Si ya pagas una suscripción de las grandes, entra con ella y no gastas clave: la sesión es la tuya. El modelo y el nivel de razonamiento se eligen por agente y por sesión, así que una pregunta rápida y una refactorización del sistema de build nunca tienen que compartir modelo.

repositorio

Pensado para repositorios, no para fragmentos.

Cada tarea corre sobre un repositorio de tu disco, con las herramientas a las que si no estarías saltando con alt-tab.

  • Git y worktrees

    Rama, diff y commit en local. Dale a cada sesión su propio worktree y dos tareas dejarán de pelearse por los mismos ficheros.

  • Editor y diffs

    Mira lo que ha cambiado en un editor de verdad antes de darlo por bueno.

  • Terminal

    Una shell viva en la misma sesión: los comandos aprobados y los tuyos comparten contexto.

  • Transcripción en directo

    La salida según ocurre — tokens, llamadas a herramientas, resultados — en vez de una ruleta y luego un muro de texto.

remoto

Sigue el plan desde el móvil.

Un plan empezado en el escritorio se puede seguir desde otro dispositivo de tu propia red. La app de escritorio sigue siendo el motor; el móvil solo es una ventana.

  • Apagado por defecto. El gateway lo enciendes tú en ajustes cuando lo quieres.
  • El emparejamiento es un código QR, y cada dispositivo tiene su propio token, revocable por separado.
  • El tráfico se queda en tu red: no hay ningún relay por medio.

precio

Gratis durante la beta.

La app entera, en tu máquina, sin coste mientras dure la beta. Sin cuenta atrás de prueba, sin tarjeta que meter, sin nada que se apague a los quince días.

  • Qué pagas por los modelos

    A nosotros, nada. Un modelo local te cuesta electricidad; una clave de la nube te la factura ese proveedor, igual que hoy.

  • Qué costará después

    No está cerrado, y no vamos a inventarnos una cifra para rellenar este hueco. Lo que sí está cerrado: trabajar en tu máquina, tú solo, es lo que va en la parte gratis. Trabajar en equipo sobre proyectos compartidos se paga, y se pagará por persona.

  • Qué te llevas por entrar pronto

    Quien esté aquí durante la beta conserva ventaja cuando haya precio. Se dirá en voz alta antes de cobrarle a nadie, nunca después.

dudas

Preguntas

¿Esto es otro Jira?

No. Un gestor de tareas guarda un ticket que alguien tiene que ir a ejecutar aparte. Aquí, cerrar el análisis es lo que autoriza el trabajo, y ese mismo documento es contra lo que el agente ejecuta sus tareas — el plan no solo describe el trabajo, lo dirige.

¿Sigo necesitando Claude Code o Cursor?

No — el agente que ejecuta las tareas corre dentro del propio proyecto, no como una sesión de terminal aparte a la que copias el trabajo. Lo que esas herramientas hacen bien, hacer el trabajo, también pasa aquí; lo que no hacen, recordar la decisión y el rastro detrás de ella, es lo que añade KuroCode.

¿Y si dos queremos trabajar en el mismo plan?

Un plan lo lleva una persona a la vez: al ejecutarlo queda reservado, y los demás ven avanzar sus tareas sin pisarlo. Cuando lo sueltas, se guarda un resumen de qué hiciste y qué queda, y quien lo retome parte de tu rama, en el último commit publicado. El código va por git; nosotros solo movemos el plan.

¿Para qué sistemas puedo descargarlo?

Los tres: macOS, Windows y Linux. macOS requiere Apple Silicon (ARM64). Windows usa instalador x64 y Linux tiene AppImage para x64 y ARM64. El Mac va notarizado por Apple y el de Windows firmado con certificado de identidad verificada.

¿Hace falta cuenta, y qué guarda?

Sí, hace falta cuenta. Entras con contraseña o con Google. La cuenta guarda tu correo, nombre, apellido, país, un identificador, el día que te diste de alta y el último que abriste la app. Y si trabajáis en equipo, el proyecto —la idea, el análisis, los planes, las aportaciones y los documentos que adjuntéis— también se guarda, porque es lo que hace falta para que varias personas escriban sobre lo mismo. Tu código y tus prompts no: ni telemetría de uso.

¿Mi código sale de mi máquina?

Solo hacia el endpoint del modelo que tú configures. Si apuntas a Ollama o LM Studio en localhost, no cruza ni la tarjeta de red. Si añades una clave de la nube, los prompts de las tareas que vayan ahí llegan a ese proveedor, como con cualquier otro cliente. Y cuando un plan cambia de manos, el código viaja por tu rama de git, no por nosotros.

¿Qué modelos funcionan de verdad?

Cualquiera servido por Ollama, LM Studio o un endpoint compatible con OpenAI, además de Anthropic y OpenAI directamente. El desarrollo se valida contra un modelo de código de 30B corriendo en una máquina local.

¿Cuánto costará?

Durante la beta, nada. Después, el reparto al que vamos es: en tu máquina y tú solo, gratis; proyectos compartidos con más gente, de pago. La cifra no está decidida, y se publicará antes de cobrarle a nadie.

¿Qué pasa cuando acabe la beta?

No se apaga nada de un día para otro ni se borra nada. Se te dirá cuál es el precio con tiempo para decidir, y quien haya entrado durante la beta conserva ventaja sobre quien llegue después.