Oh My Pi (omp.sh): Un vistazo rápido a la CLI de agentes de programación reforzada

La mayoría de los desarrolladores evalúa los agentes de programación comparando modelos de frontera: Claude Opus 5 vs GPT-5.3 vs Gemini 3.7. Ese enfoque supone que los pesos del modelo subyacente son la única variable que determina el rendimiento al programar.

Sin embargo, asigna un agente a una base de código existente de gran tamaño y pronto descubrirás el verdadero cuello de botella: el harness de ejecución.

Cuando un agente no logra resolver un problema, rara vez es porque le faltó inteligencia para diagnosticar el bug. Con más frecuencia, falla en la interfaz mecánica: los diffs con coincidencia aproximada se desalinean, las diferencias de espacios rompen los reemplazos de texto, los logs del compilador desbordan las ventanas de contexto y los subagentes concurrentes entran en conflicto al modificar archivos compartidos.

Como explicó Can Bölük (creador de oh-my-pi) en El problema del harness, culpar al modelo por estas fallas es como «culpar al piloto por el tren de aterrizaje». Optimizar solo la herramienta de edición puede cambiar hasta 10× las tasas de éxito de los modelos sin gastar cómputo en entrenamiento.

Para resolver este cuello de botella de ejecución surgió Oh My Pi (omp.sh), un harness de CLI reforzado y de alto rendimiento. A partir de la base minimalista pi-mono de Mario Zechner, omp combina ejecución nativa en Rust, aplicación determinista de parches Hashline, refactorización estructural de AST y coordinación de múltiples agentes sin dependencia de un proveedor.

Este artículo es un recorrido detallado por Oh My Pi: la tesis central detrás del problema del harness, los resultados empíricos del benchmark con 16 modelos, sus 4 diferenciadores arquitectónicos integrados, por qué los harnesses abiertos superan a los ecosistemas cerrados propietarios y cómo se compara omp directamente con OpenCode, Claude Code, Cursor Agent y Pi.dev.

TL;DR

• El problema del harness: El cuello de botella de un agente de programación a menudo no es la inteligencia del modelo, sino la interfaz entre los tokens del modelo y las modificaciones del workspace. Mejorar solo el formato de la herramienta de edición cambia las tasas de éxito de programación hasta 10× (6.7% → 68.3% en Grok Code Fast) y reduce los tokens de salida en 61%.
• Qué es Oh My Pi: Un harness de programación para terminal, rápido y de código abierto, construido sobre Bun y bindings nativos de Rust (@oh-my-pi/pi-natives). Combina portabilidad entre modelos con salvaguardas de ejecución determinista.
• Los 4 paradigmas de herramientas de edición en competencia:
  1. Codex apply_patch: Bloques de diff de OpenAI favorecidos en el gateway de API; falla en 46–51% de los turnos para modelos que no son Codex.
  2. Claude Code str_replace: Coincidencia exacta de caracteres y espacios; propenso a la fatiga causada por errores de «cadena no encontrada».
  3. Cursor Instant Apply: Modelo de fusión dedicado de 70B ajustado mediante fine-tuning; recurre a reescrituras completas de archivos de menos de 400 líneas.
  4. Oh My Pi Hashline ([PATH#TAG]): Anclas de línea basadas en hashes del contenido con control optimista de concurrencia (OCC); no requiere reproducir espacios en blanco.
• 4 diferenciadores clave integrados:
  1. Parches Hashline deterministas: Las anclas de línea con etiquetas de checksum evitan el desplazamiento silencioso de offsets al editar múltiples archivos.
  2. Preparación nativa con AST-Grep: Refactorización de árboles sintácticos que reconoce el lenguaje y se prepara en memoria antes de tocar el disco.
  3. Compactación visual con Snapcompact: Comprime conversaciones largas al renderizar turnos anteriores como PNG de mapa de bits de 1 bit para modelos de visión multimodales.
  4. El Agent Hub: Un panel TUI en vivo (Alt+A) y un broker IRC de igual a igual que supervisan grupos de subagentes concurrentes en sandboxes de copia en escritura.
• Harnesses abiertos vs ecosistemas cerrados: Los proveedores propietarios (Anthropic, Google) nunca optimizarán sus harnesses de CLI para los modelos de la competencia. Un harness de código abierto sirve como puente neutral y capa de I+D entre modelos para todo el ecosistema de IA.

Qué aprenderás aquí

• Por qué los benchmarks de modelos pasan por alto la principal fuente de fallas de los agentes en producción.
• Cómo se comparan mecánicamente los 4 paradigmas principales de edición de código (apply_patch, str_replace, modelos de fusión de 70B y Hashline).
• Los resultados cuantitativos del React Edit Benchmark en 16 LLM (8,640 ejecuciones de prueba).
• Cómo omp.sh implementa parches Hashline, preparación con AST-grep y compactación visual del contexto.
• Cómo la arquitectura de roles de modelo desacopla las tareas lógicas de los proveedores de modelos concretos.
• Una matriz comparativa de funcionalidades frente a Claude Code, OpenCode, Cursor y Pi.dev.

¿Qué es Oh My Pi? (Un recorrido de 30 segundos)

En esencia, Oh My Pi (omp.sh) es un motor de CLI centrado en desarrolladores, diseñado para ejecutar de forma segura tareas de programación de larga duración.

flowchart TB
    subgraph UserInterface ["Capa de terminal (runtime de Bun)"]
        CLI["CLI de omp y TUI interactiva"]
        HubHUD["HUD de Agent Hub (Alt+A)"]
        Router["Enrutador de niveles de modelo (Opus, GPT-5, Gemini)"]
    end

    subgraph HardenedCore ["Motor reforzado (@oh-my-pi/pi-natives)"]
        Hashline["Motor de etiquetado de snapshots Hashline"]
        AST["Núcleo de modificación con ast-grep y Tree-Sitter"]
        Compact["Compactación multinivel (Snapcompact y Shake)"]
        PAL["Capa de abstracción de plataforma (APFS CoW / OverlayFS)"]
        Mnemopi["Memoria episódica Mnemopi (SQLite-Vec)"]
    end

    UserInterface --> HardenedCore

omp ejecuta sus operaciones centrales mediante bindings N-API compilados en Rust, en lugar de scripts interpretados. Esto permite escanear el workspace en menos de un milisegundo, analizar código teniendo en cuenta su sintaxis y calcular checksums rápidamente.

El problema del harness: por qué los benchmarks de modelos pasan por alto el verdadero cuello de botella

En la ingeniería de IA, la conversación está dominada por las competencias entre modelos de frontera en las tablas de clasificación. Sin embargo, al rastrear las fallas de los agentes en repositorios existentes y realistas, el problema rara vez ocurre en el razonamiento de alto nivel.

En cambio, la falla ocurre en el harness: los esquemas de herramientas, formatos de edición, mensajes de error y capas de reconciliación de estado que traducen los razonamientos del modelo en escrituras en el sistema de archivos.

flowchart LR
    A["Obsesión de la industria<br><b>'¿Cuál es el mejor modelo?'</b><br>(Opus vs GPT-5 vs Gemini)"] -.->|Pasa por alto el verdadero cuello de botella| B["El harness de ejecución<br><b>Esquemas de herramientas y anclas de edición</b><br>(Donde ocurren la mayoría de las fallas de los agentes)"]
    B --> C["El hallazgo<br><b>'Culpar al piloto por el tren de aterrizaje'</b><br>Los modelos entienden la tarea, pero fallan en la sintaxis del diff"]

Los 4 paradigmas de herramientas de edición

¿Cómo comunica un LLM un cambio a un archivo? Las herramientas actuales para desarrolladores adoptan cuatro enfoques arquitectónicos distintos:

flowchart TD
    subgraph Paradigms ["Enfoques para modificar código en 2026"]
        P1["1. apply_patch (Codex)<br>Bloque de diff de OpenAI con sesgo de tokens en el gateway"]
        P2["2. str_replace (Claude Code)<br>Coincidencia exacta de cadenas; sin tolerancia a diferencias de espacios"]
        P3["3. Modelo dedicado de 70B (Cursor)<br>Modelo ajustado mediante fine-tuning exclusivamente para fusionar diffs"]
        P4["4. Hashline [PATH#TAG] (Oh My Pi)<br>Anclas de línea basadas en hashes del contenido + concurrencia optimista"]
    end

Por qué fallan en la práctica las herramientas de edición ingenuas

1. La trampa de la reproducción exacta (str_replace): Para reemplazar 5 líneas de código, el modelo debe reproducir perfectamente cada carácter, espacio de indentación y salto de línea. En archivos grandes, pequeñas diferencias de espacios causan el temido error «String to replace not found in file» (issue #3471 de Claude Code + 27 issues relacionados).
2. Sesgo del gateway propietario (apply_patch): OpenAI entrena sus modelos con restricciones de muestreo de tokens a nivel del gateway que obligan a cumplir su esquema de diff. Cuando proporcionas ese mismo formato a Grok 4 o GLM-4.7, las tasas de falla de los parches llegan a 50.7% y 46.2%. Los modelos entienden el código; simplemente no logran hablar el dialecto propietario de diff de OpenAI.
3. Confirmación académica: El benchmark Diff-XYZ de JetBrains confirmó sistemáticamente que ningún formato de edición domina en todos los modelos. EDIT-Bench encontró que solo un modelo supera el 60% de pass@1 en tareas de edición realistas.

4 funcionalidades integradas que distinguen a omp.sh

flowchart TD
    subgraph HardeningPillars ["Arquitectura de refuerzo de Oh My Pi"]
        F1["1. Parches Hashline deterministas<br>Checksums por línea + rechazo mediante OCC"]
        F2["2. Preparación nativa con AST-Grep<br>Refactorización de árboles sintácticos en memoria"]
        F3["3. Snapcompact visual<br>Compactación de conversaciones en PNG de mapa de bits de 1 bit"]
        F4["4. Agent Hub supervisado<br>Sandboxes CoW + mensajería IRC entre pares"]
    end

1. Parches Hashline deterministas ([PATH#TAG])

En lugar de obligar al modelo a reproducir código literalmente o adivinar números de línea que cambian, Oh My Pi etiqueta cada vista de archivo leída con una huella de checksum de 4 dígitos hexadecimales:

[src/auth/session.ts#4F1A]
1:export interface SessionConfig {
2:    ttlMs: number;
3:    jwtSecret: string;
4:}
5:
6:export function createSession(config: SessionConfig) {
7:    return new SessionStore(config);
8:}

Al modificar código, el agente apunta a la etiqueta del snapshot mediante operadores de bloques sintácticos:

[src/auth/session.ts#4F1A]
PUT 6*:
+export function createSession(config: SessionConfig, logger?: Logger) {
+    if (logger) logger.info("Initializing session store");
+    return new SessionStore(config);
+}

• PUT N*: reemplaza todo el nodo AST (función, clase, interfaz) que comienza en la línea N, resuelto automáticamente por Tree-sitter.
• Control optimista de concurrencia (OCC): Si otro proceso o subagente modifica session.ts, la etiqueta del archivo cambia (por ejemplo, a #9B2E). Cuando el agente envía una edición contra #4F1A, el motor rechaza el parche de inmediato, evitando colisiones silenciosas de código antes de escribir en disco.

sequenceDiagram
    autonumber
    actor LLM as Agente de programación
    participant Harness as Harness de Oh My Pi
    participant FS as Sistema de archivos local

    LLM->>Harness: Leer src/auth/session.ts
    Harness-->>LLM: Devuelve el contenido con la huella [session.ts#4F1A]
    Note over LLM,FS: Un proceso en segundo plano actualiza session.ts (la etiqueta pasa a ser #9B2E)
    LLM->>Harness: PUT 6*: [session.ts#4F1A] (Nueva implementación)
    Harness->>Harness: Verificar etiqueta actual (#9B2E) == etiqueta de la solicitud (#4F1A)
    Harness-->>LLM: ERROR: La etiqueta no coincide. El archivo se modificó desde la última lectura. Es necesario volver a leerlo.
    Note over LLM,FS: ¡Se evitó la corrupción del código! El agente vuelve a leer el estado actualizado y tiene éxito.

Resultados del React Edit Benchmark

Para medir el impacto del diseño de herramientas de edición en el mundo real, Can Bölük ejecutó el React Edit Benchmark: 16 modelos × 3 ejecuciones × 180 tareas de la base de código de React (8,640 sesiones en total), comparando apply_patch, str_replace y hashline:

Conclusiones clave de los datos:

1. Hashline superó a patch en 14 de 16 modelos, y Hashline v2 mejoró aún más los resultados en 12 de 16 modelos.
2. Los modelos más débiles fueron los que más ganaron: Grok Code Fast 1 saltó de 6.7% a 68.3% porque su capacidad real de programación estaba oculta por fallas mecánicas de edición.
3. Reducciones enormes de tokens: Los tokens de salida de Grok 4 Fast disminuyeron en 61% porque el agente dejó de consumir contexto en ciclos interminables de reintentos de «falló el parche, volver a leer el archivo».
4. Sin costo de cómputo de entrenamiento: Gemini 3.7 Flash ganó entre +5.0 y +8.0 pp respecto al mejor intento de Google, sin reentrenar el modelo y con un gasto de ~$300 en la API para el benchmark.

2. Preparación nativa con AST-Grep (ast_edit)

Para refactorizar múltiples archivos, buscar y reemplazar con expresiones regulares es notoriamente peligroso. Oh My Pi incluye transformaciones estructurales nativas de AST mediante ast_edit:

sequenceDiagram
    autonumber
    actor Agent as Agente de programación
    participant Rust as Motor de AST en Rust (ast-grep)
    participant Staging as Buffer de preparación en memoria
    participant FS as Sistema de archivos local

    Agent->>Rust: Enviar patrón de AST (por ejemplo, async function $F($$$ARGS))
    Rust->>Rust: Analizar CST y buscar nodos estructurales coincidentes
    Rust->>Staging: Preparar diff propuesto
    Staging-->>Agent: Vista previa del diff estructurado [PATH#TAG]
    alt Aplicar edición verificada
        Agent->>FS: write xd://resolve
        FS-->>Agent: Escritura atómica aplicada en disco
    else Descartar
        Agent->>Staging: write xd://reject
        Staging-->>Agent: Buffer de preparación descartado
    end

Las ediciones de AST buscan coincidencias en nodos sintácticos en lugar de espacios o caracteres. Como resultado, los comentarios, el formato y los métodos adyacentes permanecen intactos.

3. Compactación visual del contexto (Snapcompact y Shake)

Cuando una sesión de programación dura horas, gestionar el uso de tokens es fundamental. Oh My Pi utiliza un pipeline de compactación multinivel:

1. Shake (omisión de logs): Los logs extensos del compilador y de las ejecuciones de pruebas se interceptan al llegar. Las líneas iniciales y finales permanecen en el contexto, mientras que el flujo completo se escribe en el almacenamiento de la sesión: artifact://12. Si es necesario, el agente recupera fragmentos bajo demanda mediante read(path="artifact://12:500-550").
2. Snapcompact (compresión visual): Para modelos con capacidades de visión (Composer 2.5 Fast, Gemini 3.7 Flash, GPT-5), los turnos anteriores se renderizan como mapas de bits PNG monocromáticos de 1 bit usando fuentes de píxeles personalizadas (11on16-bw). El modelo multimodal lee el contexto anterior directamente desde la imagen, reduciendo la cantidad de tokens activos y preservando la capacidad de recuperación mediante OCR.

4. El Agent Hub y los grupos aislados de agentes

Para paralelizar el trabajo sin poner en riesgo tu directorio de trabajo, Oh My Pi proporciona el Agent Hub:

flowchart TB
    Main["Agente coordinador<br><code>task(tasks=[{AuthMigrator}, {DbAuditor}])</code>"]

    subgraph Swarms ["Grupo supervisado de subagentes"]
        Auth["Subagente: AuthMigrator<br>(Rol: task)"]
        Db["Subagente: DbAuditor<br>(Rol: scout)"]
    end

    subgraph Sandboxes ["Capa de abstracción de plataforma (PAL)"]
        S1["Clon de copia en escritura de APFS #1"]
        S2["Montaje de OverlayFS #2"]
    end

    Main --> Swarms
    Auth --> S1
    Db --> S2
    Auth <-->|Mensajería IRC de igual a igual| Db

• Virtualización del workspace: Usa clones de copia en escritura de APFS en macOS y montajes de OverlayFS en Linux. Cada subagente obtiene un sandbox aislado en <10ms.
• IRC de igual a igual: Los subagentes se comunican directamente mediante mensajes estructurados (hub(op="send", to="DbAuditor")) sin aumentar innecesariamente la conversación principal.
• Panel TUI: Al presionar Alt+A se abre el HUD en vivo de Agent Hub para monitorear el progreso de los subagentes, inspeccionar logs y administrar servidores de desarrollo en segundo plano.

Ecosistemas cerrados de proveedores vs la ventaja estratégica del harness abierto

A principios de 2026, Anthropic bloqueó el acceso de OpenCode a Claude a través de suscripciones de usuarios. Aproximadamente al mismo tiempo, Google bloqueó las cuentas de desarrolladores que hacían benchmarks de modelos Gemini a través de harnesses abiertos de terceros.

Estas acciones reflejan una estrategia agresiva hacia herramientas para desarrolladores ligadas a un proveedor: «No construyas harnesses. Usa el nuestro».

flowchart LR
    subgraph WalledGardens ["CLI propietarias de un solo proveedor"]
        Anthropic["Claude Code<br>(solo Anthropic)"]
        OpenAI["Codex CLI<br>(solo OpenAI)"]
        Google["Gemini Code<br>(solo Google)"]
    end

    subgraph OpenBridge ["La ventaja estratégica del harness abierto (omp.sh)"]
        OMP["Harness de Oh My Pi<br><b>Puente neutral entre modelos</b>"]
    end

    WalledGardens -.->|Nunca optimizarán para la competencia| OMP
    OMP --> SharedRD["I+D compartida del ecosistema<br>Optimizada para todos los modelos simultáneamente"]

Por qué los harnesses cerrados limitan la velocidad de desarrollo

1. Ningún proveedor optimiza para la competencia: Anthropic nunca ajustará los esquemas de edición de Claude Code para Grok. OpenAI nunca optimizará sus herramientas de parches para Claude. xAI nunca hará ajustes para Gemini.
2. Los harnesses abiertos ofrecen I+D gratuita al ecosistema: Cuando un harness de código abierto ajusta una herramienta de edición (como Hashline) y mejora Gemini Flash en +8% o Grok en 10×, proporciona optimización gratuita a los creadores de los modelos.
3. El harness como puente: Como señaló Can Bölük: «El modelo es la ventaja estratégica. El harness es el puente. Quemar puentes solo significa que menos personas se molestarán en cruzarlos».

Al mantener el harness abierto, modular e independiente del modelo, omp garantiza que los desarrolladores no queden rehenes de las limitaciones de la CLI de un solo proveedor.

Cómo funcionan los roles de modelo: desacoplar la arquitectura de los endpoints

Una de las decisiones de diseño más claras de Oh My Pi es su sistema de roles de modelo (omp.sh/docs/roles).

La mayoría de los agentes de programación te obliga a codificar de forma fija identificadores de modelos (como cursor/composer-2.5-fast) en todas las configuraciones o a depender de un solo proveedor. Oh My Pi desacopla el rol funcional que cumple un modelo del endpoint concreto del proveedor que lo atiende.

flowchart LR
    UserPrompt["Paso del flujo de trabajo del agente"] --> Roles

    subgraph Roles ["Roles lógicos de modelo"]
        Default["@default<br>Programación y ediciones principales"]
        Slow["@slow<br>Razonamiento complejo y arquitectura"]
        Smol["@smol<br>Exploración rápida y procesamiento de logs"]
        Tiny["@tiny<br>Títulos de sesión e indexación de memoria"]
        Reviewer["@reviewer<br>Auditoría de seguridad adversarial"]
    end

    subgraph Providers ["Endpoints de proveedores configurados"]
        Composer["Composer 2.5 Fast"]
        Opus["Claude Opus 5 High:high"]
        Gemini["Gemini 3.7 Flash:minimal"]
        Local["Llama local / Ollama"]
        GPT["GPT-5.6 Sol"]
    end

    Default --> Composer
    Slow --> Opus
    Smol --> Gemini
    Tiny --> Local
    Reviewer --> GPT

Lista de roles estándar

Optimizaciones económicas clave

1. Alias de roles y modificadores de razonamiento: Puedes encadenar alias y fijar niveles de esfuerzo de razonamiento directamente para un rol en config.yml (por ejemplo, slow: "anthropic/claude-opus-5-high:high" o smol: "google/gemini-3-7-flash:minimal").
2. Transferencia de costos con Prewalk (--prewalk): Cuando ejecutas --prewalk, omp inicia la sesión usando @slow o @plan para generar una arquitectura de alto nivel y un desglose de tareas. En cuanto comienza la primera edición de código o escritura de archivo, el motor cambia automáticamente a @smol (--prewalk-into), ahorrando hasta 70–80% en costos de inferencia durante la implementación mecánica.
3. Cadenas de promoción de contexto: Si un modelo con contexto pequeño alcanza un límite de longitud, omp puede promover automáticamente el turno activo a un modelo relacionado de mayor capacidad (por ejemplo, codex-spark → gpt-5.5) antes de recurrir a la compactación.

Caso de uso en producción: roles por niveles de Pareto en grupos de agentes de CI/CD

En nuestro análisis anterior sobre cómo construir plataformas de agentes ultrarrápidas en Kubernetes con ArgoCD y Ante, examinamos la frontera de Pareto de velocidad frente a calidad de 2026. La conclusión central fue clara: asignar cada tarea de agente a un modelo de frontera pesado provoca graves cuellos de botella de latencia y sobrecostos de 5–10×.

El sistema de roles de Oh My Pi te permite configurar un pipeline de Pareto óptimo con múltiples proveedores en config.yml:

flowchart TD
    Webhook["Git Push / webhook de Jira"] --> Pod["Job efímero de Kubernetes KEDA"]
    
    subgraph SwarmPipeline ["Pipeline de ejecución de Pareto de Oh My Pi"]
        Scout["1. Clasificación rápida y arqueología<br><b>@smol (Gemini 3.7 Flash @ 362 tok/s)</b><br>Ejecuta git log, explora directorios y analiza logs"]
        Plan["2. Descomposición arquitectónica<br><b>@slow (Claude Opus 5 High:max)</b><br>Genera un contrato de pruebas y un plan con --prewalk"]
        Exec["3. Implementación determinista<br><b>@default (Composer 2.5 Fast)</b><br>Aplica ediciones Hashline [PATH#TAG] en un sandbox APFS"]
        Review["4. Control de seguridad ortogonal<br><b>@reviewer (GPT-5.6 Sol)</b><br>Revisión adversarial para eliminar los puntos ciegos cognitivos de un solo modelo"]
    end

    Pod --> Scout
    Scout --> Plan
    Plan --> Exec
    Exec --> Review
    Review --> PR["PR abierto en verde con pruebas de CI verificadas"]

1. Exploración de alto rendimiento (@smol → Gemini 3.7 Flash): Con una generación de 362 tok/s, Gemini Flash realiza exploraciones amplias de la base de código, clasificación de logs de pruebas y OCR de Snapcompact en segundos sin consumir tokens costosos.
2. Síntesis arquitectónica profunda (@slow → Claude Opus 5): Reservado para el modo de planificación (--plan), el análisis de causas raíz y la definición de especificaciones de pruebas que fallan.
3. Implementación quirúrgica (@default → Composer 2.5 Fast): El bucle principal de programación que escribe código según el contrato de hashline anclado al snapshot.
4. Revisión adversarial ortogonal (@reviewer → GPT-5.6 Sol): Cuando un modelo ejecutor revisa su propia salida, comparte los mismos puntos ciegos cognitivos. Enrutar la validación final del PR a una familia de modelos independiente (OpenAI GPT-5.6) permite detectar bugs lógicos en casos límite antes de fusionar el código.

Cómo se compara omp.sh con la competencia

Inicio rápido de 2 minutos: configuración y enrutamiento entre modelos

Configura tus niveles de modelo en ~/.omp/agent/config.yml:

# ~/.omp/agent/config.yml
models:
  default: "cursor/composer-2.5-fast"
  slow: "anthropic/claude-opus-5-high"    # Architectural planning
  smol: "google/gemini-3-7-flash"         # Fast scouting & Snapcompact
  reviewer: "openai/gpt-5.6-sol"          # Adversarial code review

task:
  batch: true
  maxConcurrency: 8
  isolation:
    mode: "auto" # APFS on macOS, OverlayFS on Linux

compaction:
  enabled: true
  methodOrder: ["remote", "snapcompact", "handoff", "shake", "soft"]
  asyncEnabled: true

memory:
  backend: "mnemopi"

mnemopi:
  scoping: "per-project"
  autoRecall: true
  autoRetain: true

Inicia una tarea de refactorización desde tu terminal:

omp "Refactor user authentication to support Passkeys/WebAuthn and update DB schema"

Dentro de la sesión, omp crea un sandbox de copia en escritura de APFS, carga la memoria del proyecto, despacha exploradores en segundo plano con Gemini Flash y aplica parches de AST verificados con Opus.

Cuándo elegir Oh My Pi

flowchart TD
    Start{"¿Cuál es tu flujo de trabajo principal de desarrollo?"}
    Start -- "Programación en pareja con IDE / GUI" --> Cursor[Elige Cursor Agent]
    Start -- "Programación en terminal solo con Anthropic" --> Claude[Elige Claude Code]
    Start -- "CLI reforzada multimodelo para monorepos" --> Omp[Elige Oh My Pi<br><b>omp.sh</b>]
    Start -- "Construir un agente personalizado desde cero" --> Pi[Elige Pi.dev]

Elige Oh My Pi (omp.sh) cuando:

• Trabajas en monorepos grandes de código existente donde las diferencias de espacios en str_replace o la coincidencia aproximada de parches causan roturas silenciosas del código.
• Quieres enrutamiento entre modelos sin quedar atado al ecosistema cerrado de la CLI de un solo proveedor de IA.
• Ejecutas tareas autónomas largas que necesitan compactación visual del contexto (Snapcompact) para preservar la precisión sin disparar los costos de tokens.
• Quieres grupos supervisados de subagentes que se ejecuten de forma concurrente en sandboxes aislados de copia en escritura.

Fuentes

1. El problema del harness: Can Bölük, Mejoramos la programación de 15 LLM en una tarde. Solo cambió el harness, stencil.so/blog/the-harness-problem (2026).
2. React Edit Benchmark: Stencil y el equipo de Oh My Pi, Harness de benchmark de edición multimodelo de la base de código de React, github.com/can1357/oh-my-pi (2026).
3. Benchmark Diff-XYZ: JetBrains Research, Diff-XYZ: Un benchmark sistemático de formatos de modificación de código para modelos de lenguaje grandes, arXiv:2510.12487 (2025).
4. EDIT-Bench: Microsoft Research y UIUC, EDIT-Bench: Evaluación de LLM en tareas realistas de ingeniería de software con múltiples archivos, arXiv:2511.04486 (2025).
5. Tabla de clasificación y benchmarks de formatos de edición de Aider: Paul Gauthier, Benchmarks de edición de código con LLM y evaluaciones de formatos de Aider, aider.chat/docs/benchmarks.html (2024–2026).
6. Cursor Instant Apply: Cursor Engineering, Instant Apply: Entrenamiento de un modelo de 70B para fusionar código, cursor.com/blog/instant-apply (2025).
7. Referencia de arquitectura de Oh My Pi: Equipo de Oh My Pi, Referencia de arquitectura y especificaciones de herramientas de Oh My Pi (omp.sh), omp.sh (2026).
8. Harness mínimo de Pi: Mario Zechner, pi-mono: Un harness mínimo de agente de programación para terminal, github.com/badlogic/pi-mono (2025–2026).
9. Herramientas AST-Grep: Herrington Darkholme, ast-grep: Búsqueda y reemplazo estructural de código políglota y rápido, ast-grep.github.io (2025).
10. Parser incremental Tree-sitter: Max Brunsfeld et al., Sistema de parsing Tree-sitter, tree-sitter.github.io (2025).
11. Anthropic Claude Code: Anthropic Engineering, Arquitectura de la CLI de Claude Code, docs.anthropic.com (2026).
12. Agente de terminal OpenCode: Equipo de OpenCode, Repositorio de la CLI de agentes OpenCode, github.com/opencode-ai/opencode (2026).
13. Fusión de rangos recíprocos: Cormack, Clarke y Buettcher, Fusión de rangos recíprocos en la recuperación de información, SIGIR (2009).