Honey Agent Skill by GreenPT

🍯 Honey (I Shrunk the AI)

Escribe menos código y di menos sobre ello. Honey (I Shrunk the AI) de GreenPT es una habilidad de codificación multiplataforma que reduce el uso de tokens de los agentes de codificación de IA y los costos de API de LLM — haciendo que los agentes emitan menos código y menos prosa sin perder corrección. Funciona con Claude (claude.ai y la API), Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf, Cline, OpenClaw, oh-my-pi, Kiro, Kilo Code y Hermes Agent. Tres palancas independientes, aplicadas de forma refleja:

1. Menos código — YAGNI primero. Recorre una escalera (¿necesita existir? → biblioteca estándar → nativo del lenguaje → dependencia existente → una línea → bloque mínimo) y detente en el primer peldaño que funcione. La línea más barata es la que nunca escribes.
2. Menos prosa — elimina el preámbulo, las vacilaciones y la narración de código que ya habla por sí mismo. Responde primero.
3. Transferencias más densas entre agentes — cuando el lector es otro agente, no un humano, entrégale el formato más eficiente en tokens que pueda analizar sin pérdidas (JSON compacto / en columnas, o ESON). Reduce el tamaño de la transferencia ~a la mitad sin pérdida de recuperación. Se activa solo aquí — nunca como respuesta dirigida al usuario.

Honey combina lo que Ponytail (código mínimo) y Caveman (prosa concisa) hacen por separado, y luego va más allá:

• Auto-intensidad — lite / full / ultra elegidos de forma refleja según la solicitud, sin impuesto de deliberación (nunca gasta tokens de razonamiento decidiendo cómo cumplir — eso frustraría el propósito en modelos de razonamiento).
• Excepciones de seguridad — validación de entrada, manejo de errores, autenticación, secretos, migraciones, eliminaciones y cualquier cosa que pidas explícitamente nunca se comprimen. Perezoso ≠ roto.
• Una familia de habilidades, no un solo prompt — un núcleo siempre activo más satélites bajo demanda (review, eco, gain, compress) y una colmena de subagentes de solo lectura que devuelven transferencias comprimidas. Consulta Habilidades y subagentes.

Por qué

El volumen es costo. En sesiones de codificación agénticas, el volumen de código y prosa generados es lo que incrementa la factura — y la mayor parte es desperdicio.

Este repositorio incluye un benchmark reproducible (bench/) para que no tengas que confiar en los números: 23 tareas en tres tipos de trabajo — línea base vs Caveman vs Ponytail vs Honey — mismo modelo, mismos prompts, solo cambia la habilidad. La corrección es objetiva (pruebas unitarias, verificaciones estructurales / de accesibilidad y recuperación sin pérdidas para transferencias entre agentes); la calidad se puntúa con un panel de jueces de 4 modelos de distintas familias (mediana de Opus 4.8 + Sonnet 4.6

• Haiku 4.5 + GPT-5.5) bajo una rúbrica neutral que no menciona la longitud, de modo que una habilidad concisa no recibe ventaja injusta. Las cifras siguientes son los resultados confirmados (Claude Opus 4.8, 3 ejecuciones cada uno) — ejecuta cd bench && npm run bench para reproducirlos.

Cada número es un delta por tarea emparejado vs la línea base — las ejecuciones se colapsan por mediana, las tareas se emparejan y la cifra es la mediana de esos deltas emparejados con una prueba de Wilcoxon de dos colas p. No es una proporción de totales por brazo: eso está dominado por la tarea que resulte más larga, y así es como las herramientas de ahorro de tokens terminan publicando números que nadie puede reproducir. Los puntos finales y la escalera de ejecución están pre-registrados en bench/METHODOLOGY.md.

En Claude Opus 5 (23 tareas × 3 ejecuciones, 207 celdas, cero rechazos o truncamientos — full-opus5-lean):

	Δ LOC	Δ salida	Δ costo	Pruebas
Honey	−71% (p<0.001)	−38% (p<0.001)	−24% (p<0.001)	100%

Honey es el único brazo sin ninguna celda fallida — la línea base sin habilidad falla cuatro. Y el recorte es mayor en el modelo más nuevo, no menor: −71% LOC en Opus 5 frente a −39% en Opus 4.8. Eso contradice la guía de prompts de 2026 que dice que los modelos más nuevos necesitan menos instrucción, lo cual probamos directamente y rechazamos — consulta METHODOLOGY.md.

Un solo número combinado oculta la historia, porque las palancas se activan de manera diferente según el tipo de tarea. Honey en Opus 4.8, donde se ejecutó el conjunto completo de competidores — Δ LOC mide la Palanca 1 directamente, Δ salida mide los tokens (código y la prosa que lo rodea):

Nivel de tarea	tareas	Δ LOC	Δ salida
Código	14	−53% (p=0.002)	−39% (p=0.007)
Dirigido al usuario	7	−23% (p=0.022)	−7% (p=0.673 — un empate)
Agente a agente	2	— (sin código)	−49% (n=2, sin p)
suite completa	23	−43% (p<0.001)	−29% (p=0.020)

Contra los competidores en la suite completa (ganar/perder/empatar del juez por prueba de signo exacta):

Variante	Δ LOC	Δ salida	Juez G/P/E	Pruebas
Caveman	−28% (p<0.001)	−22% (p<0.001)	3/16/2, p=0.004	94%
Ponytail	−33% (p=0.028)	−7% (ns, p=0.267)	1/19/1, p<0.001	90%
Honey	−43% (p<0.001)	−29% (p=0.020)	8/11/2, p=0.648	100%

• Código — el recorte más profundo (−39%) con 100% de aprobación en pruebas unitarias. La auto-verificación obligatoria de Ponytail infla el código trivial (+60% en Opus, +92% en GPT-5.5).
• Dirigido al usuario — la excepción evita que Honey comprima el pulido: el delta de salida aquí es un empate estadístico, y Honey mantiene el único 100% de aprobación de accesibilidad mientras Ponytail cae al 81% en la lista de verificación estructural/a11y.
• Agente a agente — bajo consultas de relevo adversariales (ordinal, anidado, ausencia, conteo entre campos) Honey es la única variante que se mantiene 100% sin pérdidas mientras reduce aproximadamente a la mitad el tamaño de la transferencia; Caveman y Ponytail comprimen más y pierden recuperación (67% / 50%). Su victoria más grande y limpia — en 2 tareas, por lo que no hay valor p.
• La calidad es un empate en general (p=0.648) — menos tokens sin costo medible de calidad, no mayor calidad. Pero el empate de la suite completa son dos efectos opuestos que se cancelan: en Opus, Honey gana en lo dirigido al usuario 6/0/1 (p=0.031) y pierde el juez de código 2/11/1 (p=0.022) — en tareas donde todas las variantes aprueban el 100% de las pruebas unitarias, por lo que es una penalización estilística por concisión, no por corrección. Ninguno de los efectos se replica en GPT-5.5 (p=0.375 / p=1.000), así que trata la caída del juez de código como sugerente, no establecida. La media del juez de Caveman también empata con la línea base exactamente — pero emparejado, pierde 16 de 23 tareas (p=0.004). Las medias ocultan eso; las pruebas de signo no.
• El ahorro en dólares no está probado con este tamaño de muestra. −21% en Opus es p=0.104 — no significativo en 23 tareas. El volumen de salida ha bajado; la factura aún no es una afirmación.

El recorte de salida se mantiene en GPT-5.5 (−20%, p=0.004; tabla completa de dos proveedores en bench/README.md), pero allí el costo sale +14% (ns) porque no se activó el almacenamiento en caché de prompts en ese brazo, por lo que cada tarea pagó el prompt de la habilidad desde cero. Honey es la única variante sin regresiones en pruebas en los tres niveles en Opus.

Medición agéntica de extremo a extremo (entorno Cline)

npm run bench hace una llamada API por tarea — limpio para aislar la palanca de salida, pero nunca ejercita un bucle de agente, esquemas de herramientas o crecimiento de contexto multiturno, donde realmente vive la factura de tokens de un agente real. bench/src/cline-bench.js (npm run bench:cline) ejecuta cada tarea a través de la CLI de Cline sin interfaz gráfica, por lo que los tokens medidos son agénticos de extremo a extremo — prompt del entorno y cada iteración del bucle incluidos. Honey se inyecta como una regla de Cline, recomendada como el skills/honey/cline-rule.md económico por turno (el núcleo operativo; el SKILL.md completo reenviado cada turno infla la entrada). Consulta bench/README.md.

ESON — Notación Estructurada de Objetos Eficiente

Honey incluye ESON, un formato sin dependencias, primero por esquema, para transferencias entre agentes. Las claves de registros repetidas se emiten una vez; los conteos de filas declarados detectan mensajes truncados; las celdas compatibles con JSON conservan los tipos. ESON se desarrolla en su propio repositorio — Green-PT/honey-eson: la especificación normativa, implementaciones de referencia en JS + Python, vectores de conformidad, el manual canónico para LLM, el Perfil de Cable Honey y la negociación. Honey incluye el códec en eso/.

El benchmark reproducible de ESON/TOON/JSON mide bytes, dos estimaciones de tokenizador, velocidad del códec y recuperación sin pérdidas en cinco formas de transferencia entre agentes. Ejecútalo con npm run bench:eso.

printf '%s' '{"from":"reviewer","findings":[{"sev":"H","issue":"expired token"}]}' | eson encode
eson decode < handoff.eson

CCR — para salidas de herramientas de arrays enormes y redundantes

ESON es sin pérdidas, para transferencias donde cada fila importa. CCR (Compress-Cache-Retrieve) es la palanca con pérdida pero recuperable para el caso opuesto: un array uniforme largo que debes leer pero en su mayoría hojear — registros, resultados de escaneo, flujos de eventos. Mantiene una muestra informativa (puntos finales, anomalías/puntos de cambio, cabeza/cola), almacena en caché las filas descartadas localmente y deja un centinela <<ccr:HASH N_rows_offloaded>>. Nada se pierde — retrieve restaura el original por hash bajo demanda.

some-tool | eson crush          # → sampled view + sentinel; originals cached in .honey-ccr/
eson retrieve <hash>            # → the full original array, verbatim

Validado en un registro de 90 filas (opus-4.8 + gpt-5.5): −82% tokens, precisión de respuesta 96% solo con compresión, 100% con recuperación — y el único fallo con compresión fue un rechazo, no una alucinación. Benchmarks: npm run bench:ccr (tokens) y npm run bench:ccr:comprehension (calidad). La habilidad honey-ccr le dice al agente cuándo recurrir a ella.

Limitación conocida (aguas arriba): las compilaciones de Claude Code afectadas por anthropics/claude-code#68951 (una regresión presente desde ~2.1.121, aún abierta) ignoran el updatedToolOutput de un hook de PostToolUse para la herramienta Bash integrada. En esas versiones, el hook de entrada se ejecuta y guarda el original, pero el modelo aún recibe la salida sin comprimir — honey advierte una vez al inicio de la sesión cuando detecta una versión afectada. La canalización explícita (some-tool | eson crush) no se ve afectada: la compresión ocurre antes de que la salida salga de la herramienta. Por separado, los hooks necesitan Node >= 14 en el PATH con el que Claude Code los invoca — las sesiones de la aplicación de escritorio heredan el PATH de launchd, no el de tu perfil de shell, por lo que un /usr/local/bin/node desactualizado es común; el hook ahora advierte en lugar de fallar silenciosamente.

PX — lecturas renderizadas como imagen para grandes volúmenes densos de solo lectura

La intuición: enviar un archivo como texto paga por carácter; enviar una imagen paga por píxel, sin importar cuánto texto se le meta. Así que una "foto de la página" cuesta ~5× menos que la página misma — y leerla tiene problemas de foto: la esencia sobrevive, un número de serie exacto podría no.

Concretamente: el texto denso empaqueta ~3 caracteres por token de imagen vs ~1 como texto. PX explota la brecha en la ruta de lectura: cuando el agente debe hojear algo enorme que nunca editará (código de proveedor, un diff grande, documentación), lo renderiza a páginas PNG con export y Reads de pxpipe las imágenes en lugar del texto.

npx pxpipe-proxy export --json --out "$TMPDIR" src/   # → page-*.png + factsheet.txt + token report

Medido: hasta −85% tokens en una sola lectura. Benchmark de corpus de repositorio (npm run bench:px, resultados): −79…85%, −82% promedio (26.4k tokens de texto de Claude → 4.8k estimados de imagen); ~−75% todo incluido por lectura después del gasto general de la hoja de datos + informe; la factura de extremo a extremo del proxy de pxpipe mide −59…70% a nivel de carga de trabajo completa.

La comprensión es una historia de Fable. El panel en vivo de 4 modelos (node bench/px/comprehension.mjs — 10 preguntas byte-exactas, texto vs renderizado):

modelo	texto	desde renderizado
Claude Fable 5	10/10	7/10
Claude Opus 4.8	10/10	4/10
Claude Sonnet 4.6	10/10	4/10
Claude Haiku 4.5	10/10	1/10
Solo los modelos de clase Fable leen los renders de manera utilizable — e incluso Fable no es seguro a nivel de bytes.
Pérdida en cadenas exactas — las lecturas erróneas son confabulaciones silenciosas (Haiku respondió a una
pregunta semilla con 0x9e3779b9, una constante que no está en el archivo), por lo que la exportación
envía tokens de precisión verbatim (rutas, SHAs, números) como texto factsheet.txt, y
la habilidad honey-px lo prohíbe para archivos que editarás, secretos o lectores
no-Fable. Sobre la API cruda, antepone el banner prompt.txt de la exportación — la
capa de seguridad de Fable rechaza renders densos sin envoltura. Complementario a CCR: CCR elimina
filas redundantes de forma recuperable; PX mantiene todo a la vista a precios de píxeles. En
/honey ultra la habilidad central recurre a PX automáticamente en lecturas calificadas
(grandes, densas, de solo lectura); en otras intensidades permanece bajo demanda vía honey-px.
Para la
versión completa a nivel de cable (prompt del sistema, documentación de herramientas, historial), ejecuta el proxy
pxpipe en sí — Honey y pxpipe se apilan.

Elige Honey cuando quieras la mejor calidad por token, especialmente en Claude Code.

Precompresión de entrada — un resultado negativo medido

Las tres palancas anteriores reducen la salida. Hay desperdicio simétrico en el lado de la entrada — relleno, cortesías y frases repetidas en el propio prompt. hooks/precompress.js es un compresor determinista, sin modelo que los elimina antes de que el prompt llegue al LLM, protegiendo código, rutas, URLs, cadenas entre comillas dobles y números verbatim (nunca toca un token que necesites exacto).

printf '%s' 'Hi! Could you please write a function `add(a, b)` that returns their sum? Thanks so much in advance!' | node hooks/precompress-cli.js
# -> write a function `add(a, b)` that returns their sum? in advance!

Es seguro y sin pérdidas (35/35 comprobaciones de propiedades; en 10 tareas probadas unitariamente la salida del modelo pasa 100%→100% de prompts completos vs comprimidos), y en prompts locuaces reduce mucho — −16.5% mediana en un corpus verboso escrito a mano.

Pero ese corpus lo favorece. Medido en 266 prompts reales escritos por humanos de 35 sesiones reales (bench/input/RESULTS.md), la reducción es 2.5% total, mediana 0% — 219 de 266 prompts no se comprimen en nada, porque los prompts reales ya son concisos y llevan casi nada de relleno. La compresión determinista sin modelo no puede capturar la reformulación replanteada (eso necesita un modelo), así que este es el techo real, no un problema de ajuste.

La conclusión honesta: el prompt es el objetivo equivocado. El volumen real de entrada en codificación agéntica es la salida de herramientas (el dominio de CCR) y el contexto re-pegado entre turnos — no cortesías humanas. Esto se envía como un filtro CLI para el caso de prompts locuaces; no está conectado siempre activo, porque en tráfico real ahorraría ~nada. Se mantiene aquí como un resultado negativo medido, en el espíritu del repositorio de no exagerar. Reproducir: node bench/input/tokens.mjs.

Habilidades y subagentes

Honey es un núcleo siempre activo más una familia de herramientas bajo demanda. El núcleo es un estilo de escritura (debe ser el predeterminado para que valga la pena); el resto son acciones a las que recurres en un momento específico.

Nombre	Tipo	Qué hace
honey	habilidad central (siempre activa)	las tres palancas, aplicadas reflexivamente a cada respuesta — más disciplina de costo de bucle para ejecuciones recurrentes de /loop. /honey [lite|full|ultra|off]
honey-chat	prompt independiente	Honey para chat simple — el núcleo de prosa concisa, sin herramientas requeridas. Pega skills/honey-chat/SKILL.md en las instrucciones personalizadas de un Proyecto de claude.ai, un Estilo, o un prompt de sistema de API (~500 tokens); COMPACT.md (≤1,500 caracteres) cabe en los campos de instrucciones personalizadas de ChatGPT/Gemini
honey-design	habilidad satélite	para UI orientada al usuario (páginas de aterrizaje, componentes): mantiene el pulido completo renderizado, reduce tokens escribiendo el diseño de forma densa (variables CSS, clases compartidas, clamp()) — mismos píxeles, menos tokens
honey-review	habilidad satélite	revisa un diff por sobre-ingeniería + sobre-verbosidad; lista de eliminación concisa
honey-eco	habilidad satélite	CO₂ / $ / tokens ahorrados de esta sesión, desde el puerto EcoLogits confirmado
honey-gain	habilidad satélite	el marcador de referencia confirmado (lee bench/results/ en tiempo de ejecución)
honey-debt	habilidad satélite	cosecha cada marcador de atajo honey: en un libro de deuda, marcando los que no tienen disparador de revisión — para que una simplificación deliberada no pueda volverse permanente silenciosamente
honey-compress	habilidad satélite	reescribe un archivo de memoria re-leído (CLAUDE.md, AGENTS.md) de forma concisa para reducir tokens de entrada; respalda el original
honey-memory	habilidad satélite	crea + mantiene un PROJECT.md por proyecto confirmado para que los agentes dejen de redescubrir los mismos hechos en cada sesión fría; almacena solo contexto estable, no-en-el-código, mantenido honesto al vivir en git
honey-ccr	habilidad satélite	aplasta salida de herramientas de arrays grandes redundantes (registros, resultados de escaneo) a una vista muestreada; con pérdida pero recuperable vía eson crush/retrieve
honey-px	habilidad satélite	lee grandes volúmenes densos de solo lectura como páginas PNG renderizadas (npx pxpipe-proxy export) — los tokens de imagen escalan con píxeles, no con caracteres: hasta −85% en contenido denso en tokens (solo lectores de clase Fable); con pérdida en cadenas exactas, nunca para archivos que editarás
honey-loop	habilidad satélite	disciplina de costo para ejecuciones recurrentes de /loop: ritmo consciente de caché (omite la zona muerta de 300s), impulsado por eventos en lugar de sondeo, cortocircuito sin cambios, manejo de estado compacto, condición de parada
honey-superpowers	habilidad satélite	apila Honey en flujos de trabajo de subagentes estilo Superpowers: la directiva Honey para inyectar en cada prompt de despacho (variantes de trabajador + revisor). En Claude Code el hook SubagentStart del plugin lo inyecta automáticamente
honey-hive	habilidad guía	decide cuándo delegar a la colmena vs. trabajar en línea
hive-scout	subagente (haiku, solo lectura)	localiza símbolos / llamadores / configuraciones; devuelve un mapa JSON compacto con claves de id
hive-reviewer	subagente (haiku, solo lectura)	revisa un diff/archivos; devuelve hallazgos JSON columnares con claves de id
hive-builder	subagente (sonnet, ≤2 archivos)	hace una edición quirúrgica bajo la escalera; devuelve un manifiesto de cambios compacto

La colmena es la Palanca 3 con un tiempo de ejecución: cada subagente devuelve una entrega comprimida, por lo que el resultado inyectado de vuelta en el contexto del orquestador es −44–53% más pequeño con cero pérdida (npm run bench:hive). En vivo, las habilidades también se mantienen — honey −86%, honey-review −70%, hive-reviewer −43% tokens de salida con corrección aprobada (npm run bench:skills). Ver bench/hive/RESULTS.md y bench/skills/RESULTS.md.

En trabajo orientado al usuario — donde la habilidad central gasta tokens porque el pulido es la especificación — honey-design mantiene el mismo pulido renderizado por −19% tokens de salida vs sin habilidad (juez 92 vs 90), superando a la habilidad central en ambos ejes en 7 tareas de página de aterrizaje/UI. Ver bench/results/honey-design.md.

Nota de honestidad. Versiones anteriores de este README citaban calidad 92% / 78% / 73% y tokens −57% / −65% / −70% de una ejecución no publicada. Esos no se reproducen — la dispersión real de calidad es mucho más estrecha y los ahorros de tokens dependen del nivel (y Ponytail agrega tokens en código simple).

Una segunda corrección, 2026-07-29: las cifras anteriores eran ratios de totales de brazo (sum(honey)/sum(baseline)), que una tarea larga puede dominar. Todo lo anterior ahora es una mediana por tarea emparejada con un valor p. Eso movió el titular de honey de −15% a −29% — el método antiguo lo subestimaba — pero también retiró dos números que resultaron ser artefactos atípicos: la "salida −22%" de Ponytail es realmente −7% (ns), y la "calidad empatada" de Caveman es una pérdida de 16-de-23 tareas (p=0.004). Método y endpoints pre-registrados: bench/METHODOLOGY.md. Regenera cualquier cifra fuera de línea con node bench/src/report.js --stamp full-opus48 --by-type.

Instalación

Claude Code (mercado de plugins)

/plugin marketplace add Green-PT/honey-for-devs
/plugin install honey@greenpt

Luego /honey una vez para activarlo (/honey lite|full|ultra para establecer la intensidad, /honey off para detener). El estado persiste entre sesiones — un hook de SessionStart lo reactiva cada sesión hasta que ejecutes /honey off. Una insignia 🍯 muestra el modo activo en tu línea de estado. Si tu cliente autocompleta /honey a honey:honey, ese es el mismo comando.

Claude simple (claude.ai / API) — sin instalación

La edición de chat, skills/honey-chat/SKILL.md (~500 tokens), es el núcleo de prosa concisa con las palancas del arnés de agente eliminadas — nada en ella necesita herramientas. Dos formas de usarla:

• Instrucciones personalizadas de Proyecto o un Estilo (recomendado): pega el archivo. Las instrucciones se vuelven parte del prompt del sistema, por lo que Honey se aplica a cada mensaje en cada conversación — siempre activo, sin necesidad de activación. El prefijo está en caché de prompt, y los ~500 tokens de entrada se reembolsan muchas veces por la salida reducida a la mitad.
• Habilidad subida (planes de pago): comprime la carpeta honey-chat/ y súbela como una Habilidad. Más barata en reposo (solo la descripción permanece en contexto) pero carga solo cuando Claude juzga que es relevante — para un estilo de escritura siempre activo, las instrucciones de Proyecto son el mejor predeterminado.

En la API, usa el archivo como (parte de) tu prompt system. Fija la intensidad añadiendo una línea: Default to honey ultra o Default to honey lite.

Otras UIs de chat (ChatGPT, Gemini, …): el prompt es agnóstico al modelo — nada en él es específico de Claude. Los campos de instrucciones personalizadas web a menudo limitan la entrada (ChatGPT: 1,500 caracteres), así que pega la edición compacta, skills/honey-chat/COMPACT.md (≤1,500 caracteres, protegida por pruebas), en el campo "¿Cómo te gustaría que ChatGPT respondiera?" de ChatGPT o en el campo de información guardada/instrucciones de Gemini. Mismas reglas, condensadas; donde el campo permite más (Proyectos de Claude, prompts de sistema de API), prefiere el SKILL.md completo.

Instalador de una línea (asistente interactivo)

En una terminal pregunta qué agentes usas, si conectar la insignia de CO₂, soltar archivos de reglas por repositorio, y tu modo predeterminado — luego configura exactamente eso. El asistente pregunta en /dev/tty, por lo que funciona a través de curl | bash. CI/pipes y --yes recurren a la auto-detección.

macOS / Linux / WSL / Git Bash:

curl -fsSL https://raw.githubusercontent.com/Green-PT/honey-for-devs/main/install.sh | bash

Windows (PowerShell 5.1+):

irm https://raw.githubusercontent.com/Green-PT/honey-for-devs/main/install.ps1 | iex

Windows (irm | iex) se ejecuta no interactivo; clona y ejecuta node bin/install.js para el asistente. Añade bash -s -- --yes para omitir prompts. Requiere Node.js en tu PATH. Seguro de re-ejecutar; omite herramientas que no tienes.

Cada plataforma soportada

Plataforma	Instalación
Claude Code	/plugin marketplace add Green-PT/honey-for-devs luego /plugin install honey@greenpt
Codex	codex plugin marketplace add Green-PT/honey-for-devs luego codex plugin add honey@greenpt
oh-my-pi (omp)	omp plugin marketplace add Green-PT/honey-for-devs luego omp plugin install honey@greenpt
GitHub Copilot CLI	copilot plugin marketplace add Green-PT/honey-for-devs luego copilot plugin install honey@greenpt
Gemini CLI	gemini extensions install https://github.com/Green-PT/honey-for-devs
OpenClaw	clawhub install honey (compañeros: clawhub install honey-review, …)
Hermes Agent	node bin/install.js --only hermes — copia .hermes/skills/ en ~/.hermes/skills/; activa con /honey (el espacio de trabajo AGENTS.md está siempre activo)
Cursor	copia .cursor/rules/honey.mdc en tu proyecto
Windsurf	copia .windsurf/rules/honey.md en tu proyecto
Cline	copia .clinerules/honey.md en tu proyecto (consciente de tokens: el skills/honey/cline-rule.md compacto)
GitHub Copilot (editor)	copia .github/copilot-instructions.md en tu proyecto
Kiro	copia .kiro/steering/honey.md (proyecto o ~/.kiro/steering/)
OpenCode	node bin/install.js --only opencode — copia AGENTS.md a ~/.config/opencode/AGENTS.md (siempre activo en cada proyecto) y skills/ en ~/.config/opencode/skills/ como habilidades nativas; verifica con opencode debug skill
Kilo Code	copia .kilo/rules/honey.md en tu proyecto (auto-descubierto; .kilocode/rules/ también funciona)
Aider / Zed / cualquier lector de AGENTS.md	copia AGENTS.md en tu proyecto

Todos estos también se manejan automáticamente por el instalador de una línea. Ver INSTALL.md para pasos manuales, banderas y desinstalación.

Insignia de carbono (Claude Code)

Cuando Honey está activo, la línea de estado también muestra una estimación de CO₂ en vivo para la sesión y el CO₂/$ ahorrado vs una línea base sin Honey:

🍯 honey:full · 🌿 44g CO₂ (saved ~26g · $0.18)

(Ilustrativo: una sesión de Opus de ~2k tokens de salida). La estimación es un port fiel de EcoLogits v0.8.2 (verificado para coincidir exactamente con el paquete). Los parámetros del modelo provienen del propio registro de EcoLogits (hooks/eco-models.json, exportado por scripts/build-eco-models.py) — coinciden por id exacto, con respaldo a un alias por familia para modelos fronterizos demasiado nuevos para el registro. Cambios de red eléctrica según el proveedor — Anthropic en AWS Trainium (~500 gCO₂/kWh), OpenAI en Azure (~400), Google en GCP (~330). Los alias, las redes y los ahorros por modo viven en hooks/eco-config.json.

La insignia en sí se renderiza solo en Claude Code (lee la transcripción de Claude Code, donde cada modelo es un modelo Claude). El cambio de proveedor importa para scripts/eco_report.py, que se ejecuta contra cualquier transcripción: las CLI de Codex/Gemini necesitarían cada una su propio hook de statusline para mostrar una insignia en vivo allí.

Los parámetros son especulativos — Anthropic no divulga ninguno. El coeficiente bruto de EcoLogits es un límite superior de flujo único (tamaño de lote 1) — le da a una solicitud todo el conjunto de GPU para la generación completa (para Opus, ~1.9 tok/s, ~30× más lento que la realidad), lo que solo representa ~1.4 kg por 1M de tokens de salida. La producción atiende muchas solicitudes de forma concurrente, por lo que la insignia divide ese techo por una concurrencia de lote efectiva (serving_concurrency, predeterminado 32 — calibrado para que el rendimiento modelado coincida con el servicio real de ~50–70 tok/s) para mostrar el impacto servido realista. eco_report.py imprime tanto la cifra servida como el techo de flujo único. Trátalos como un rango, no como una lectura de medidor.

Para el desglose completo (uso + incorporado + energía primaria) ejecuta el paquete real:

pip install ecologits
python scripts/eco_report.py        # newest session, or --transcript PATH

honey-usage — uso real de tokens en tus agentes de codificación

honey-usage (bin/usage.js, inspirado en tokscale) lee los datos de sesión que tus agentes de codificación ya escriben en disco e informa el uso real de tokens — tokens, USD aproximado y CO₂ servido — por aplicación y modelo. Cero dependencias, sin red, nada sale de tu máquina.

Aplicación	Fuente
claude (Claude Code)	$CLAUDE_CONFIG_DIR o ~/.claude — projects/**/*.jsonl
codex (Codex CLI)	$CODEX_HOME o ~/.codex — sessions/**/*.jsonl
opencode (OpenCode)	($XDG_DATA_HOME o ~/.local/share)/opencode/opencode.db (sistema sqlite3)

Las aplicaciones sin datos se omiten; agregar otra es un pequeño escáner que devuelve registros {app, model, ts, input, output, cacheRead, cacheWrite, cost}.

honey-usage                                  # table by app + model, totals row
honey-usage --json                           # same aggregation as JSON
honey-usage --daily --since 2026-08-01       # per-day breakdown, date-filtered
honey-usage --client codex,opencode --today  # scope by app and local day

APP     MODEL        INPUT      OUTPUT   CACHE-R      CACHE-W     USD     CO2
claude  claude-opus-5  85,540  4,296,591  1,814,741,458  44,864,917  $1295.62  94.45kg
...

Detalles que mantienen honestos los números:

• Deduplicación — Claude Code repite registros de asistente entre reintentos y continuaciones; cada (message.id, requestId) cuenta una vez, globalmente.
• Costo consciente de caché — tarifas de bench/pricing.json (escrituras/lecturas de caché facturadas como multiplicadores de la tarifa de entrada; modelos desconocidos recurren a _default, así que trata $ como aproximado). Los cached_input_tokens de Codex se separan de input_tokens y se precian como lecturas de caché; las filas de OpenCode usan el costo registrado por la propia aplicación.
• CO₂ — la misma estimación servida de EcoLogits que la insignia (hooks/eco.js), a partir de tokens de salida; aplican las advertencias de la insignia.
• Los ahorros están limitados por el libro mayor — el informe predeterminado no tiene columna de "ahorrado": muestra lo que realmente se gastó, y los registros de la aplicación no registran si Honey estaba activo. honey-usage --savings reclama ahorros solo para sesiones que el hook SessionStart registró en $CLAUDE_CONFIG_DIR/.honey-usage-ledger.jsonl (Claude Code, desde que Honey se instaló — el historial anterior a eso nunca se reclama), y solo para modelos con una marca de referencia comprometida (hooks/eco-config.json savings_provenance). Todo lo demás se anota al pie, no se estima. Las cifras siguen siendo contrafactuales modelados (est. modeled from bench/results/… — not measured), misma base que la insignia.

Cómo se mantiene en sincronía

La habilidad se autoría una vez en skills/honey/SKILL.md. Cada archivo de reglas por plataforma (y AGENTS.md) se genera a partir de él:

node scripts/build-rules.js          # regenerate all rule files
node scripts/build-rules.js --check  # CI: fail if any copy drifted

Los paquetes de habilidad OpenClaw (.openclaw/skills/) y Hermes (.hermes/skills/) se generan de la misma manera a partir de skills/; vuelve a ejecutar node scripts/build-openclaw-skills.js / node scripts/build-hermes-skills.js después de cambiar una habilidad. tests/openclaw-skills.test.js y tests/hermes-skills.test.js fallan si una copia comprometida está desactualizada.

Licencia

MIT — consulta LICENSE.

Los datos de estimación de carbono y los coeficientes en hooks/eco-models.json y hooks/eco.js se derivan de EcoLogits y permanecen bajo la MPL-2.0. Consulta NOTICE para más detalles.