Claude Fable 5.2 organiza a 1000 agentes de IA para completar la formalización del último teorema de Fermat en 28,7 horas

El 9 de noviembre de 2026, Anthropic publicó en su blog oficial de ingeniería un experimento con múltiples agentes: 1000 agentes Claude Fable 5.2 colaboraron para completar en 28,7 horas la formalización computacional del último teorema de Fermat, y la demostración final superó la comprobación del núcleo oficial de Lean. Dos meses antes, en el primer experimento de formalización, participaron decenas de agentes y se necesitaron 11 días.

Esto no significa que «la IA haya demostrado el último teorema de Fermat en 30 horas». Andrew Wiles y Richard Taylor ya habían demostrado el teorema en la década de 1990. Lo que hizo este experimento fue traducir una demostración existente a una forma que una computadora pudiera verificar paso a paso. Por tanto, la pregunta que este artículo busca responder es: ¿cómo colaboraron 1000 agentes de IA para completar un proyecto tan complejo en menos de 30 horas?

Valor principal: al terminar de leer, conocerás los datos clave del experimento de formalización del último teorema de Fermat, cómo se organizaron los 1000 agentes y qué mecanismos de verificación se utilizaron, así como las posibles aplicaciones y los límites de esta experiencia para los sistemas de agentes empresariales.

Resumen de los datos clave del experimento de formalización del último teorema de Fermat

Empecemos con una tabla que resume los datos básicos del experimento con Claude Fable 5.2. Conviene aclarar algunos detalles que pueden prestarse a confusión: se utilizó una versión temprana del modelo, el experimento partía de información predefinida y la propia empresa lo describió como un toy experiment (una demostración experimental).

Formalización del último teorema de Fermat: primero, aclaremos las condiciones del experimento

Los investigadores no se limitaron a decir «demuestra el último teorema de Fermat» y dejar que el agente se las arreglara solo. Le proporcionaron 60 proposiciones —el teorema final y 59 hitos intermedios—, un resumen de la estrategia, definiciones y 47 lemas que ya se habían demostrado en el experimento anterior. Además, los investigadores definieron de antemano los roles del agente líder y los agentes auxiliares.

Así que el experimento evaluaba otra capacidad: partiendo de unas bases matemáticas y unas herramientas determinadas, ¿puede un equipo grande de agentes organizarse por su cuenta y convertir una estrategia conocida en una demostración completa que pueda comprobarse mediante una máquina? Esta pregunta se acerca más a un problema de ingeniería que a «¿puede la IA hacer matemáticas?».

Por qué es tan difícil formalizar el último teorema de Fermat

El enunciado del último teorema de Fermat es sencillo: para todo entero (n > 2), no existen enteros positivos (a), (b) y (c) que cumplan (a^n + b^n = c^n). Pierre de Fermat lo formuló en el siglo XVII y el problema quedó sin resolver durante más de 350 años. Wiles anunció una demostración en 1993; en 1994, junto con Taylor, corrigió un fallo importante, y la versión definitiva se publicó en 1995. La demostración original tenía unas 129 páginas y se apoyaba ampliamente en resultados de teoría de números moderna y geometría algebraica.

Al escribir una demostración, un matemático puede decir «se deduce claramente de lo anterior» y confiar en que el lector complete los pasos intermedios. Una computadora no puede dar nada por sentado: necesita saber qué definición, teorema o regla de inferencia se aplicó en cada paso. Ahí está la dificultad de formalizar: algo que para una persona es «evidente» puede convertirse en cientos o miles de líneas de código.

Lean, Mathlib y la formalización matemática

Para entender este experimento, conviene distinguir tres conceptos:

• Lean: un asistente interactivo de demostraciones que comprueba si una prueba cumple estrictamente las reglas de la lógica formal.
• Mathlib: la biblioteca matemática de Lean, que reúne numerosas definiciones y teoremas ya formalizados; es como una «biblioteca estándar» a la que se puede recurrir.
• Formalización matemática: convertir una demostración matemática legible para las personas en una estructura lógica que una computadora pueda verificar por completo.

Lo más importante es que la IA construye la demostración y el núcleo de Lean la comprueba. Que el modelo diga «lo he demostrado» y que Lean acepte la prueba son dos cosas muy distintas. Este experimento merece tomarse en serio precisamente porque el resultado final no depende de la valoración del propio modelo, sino de una comprobación independiente por computadora.

Cómo colaboran 1000 agentes de IA: un sistema de gestión de proyectos ejecutado por IA

Esta es una de las partes más interesantes del experimento Claude Fable 5.2. Los 1000 agentes no trabajan por separado, cada uno concentrado en resolver un problema, sino que forman un sistema colaborativo con gestión de tareas, asignación de recursos y ajustes dinámicos.

Estructura del equipo Claude Fable 5.2

El equipo tiene una estructura jerárquica sencilla: un agente líder se encarga de la planificación general, la división de tareas y el seguimiento del progreso; los otros 999 agentes ayudan con las demostraciones concretas. Cada agente dispone de su propio entorno aislado en una máquina virtual ligera, donde puede usar Shell, un editor de archivos, la cadena de herramientas de Lean y Mathlib. También tiene su propia rama de Git y puede enviar solicitudes de merge a la rama principal.

Ningún agente tiene acceso directo a Internet. Toda comunicación con Claude API, Git y las bases de datos debe pasar por una pasarela externa. Los entornos aislados y las ramas independientes permiten que los 1000 agentes modifiquen código al mismo tiempo sin sobrescribir los archivos de los demás.

PostgreSQL compartido: el centro de colaboración de los agentes de IA

Si 1000 agentes colaboran enviándose mensajes entre sí, el volumen de comunicación se descontrola rápidamente. La estrategia del agente líder consiste en crear cinco tablas compartidas en la base de datos durante los primeros 10 minutos del experimento y convertir la comunicación en «leer y escribir en el mismo tablero».

El valor de este mecanismo está en que los agentes no necesitan ponerse en contacto uno por uno con los otros 999: basta con consultar la base de datos para saber qué tareas hay, cuáles se han completado y cuáles dependen de otras. Los resultados se incorporan a la rama principal mediante una fusión de Git. Según los datos publicados oficialmente, el proceso registró unas 36.612 escrituras y 311.734 lecturas en la base de datos. De las escrituras, unas 20.600 correspondieron a Notes y unas 14.800 a Subtasks (la estadística no incluye la mayoría de las llamadas a scripts). El número de lecturas, muy superior al de escrituras, también indica que los agentes pasan la mayor parte del tiempo «consultando el estado global».

Asignación dinámica de tareas: de la distribución fija al trabajo autogestionado

El proceso de coordinación de este experimento no fue siempre igual. La siguiente cronología muestra cómo fue evolucionando la organización:

Hay dos detalles que conviene tener en cuenta. Primero, el paso de «Lead asigna las tareas» a «los agentes las reclaman por su cuenta» equivale a que el equipo pase de una coordinación centralizada a un modelo de bolsa de tareas, lo que reduce el riesgo de que Lead se convierta en un cuello de botella. Segundo, el experimento se reanudó desde un estado guardado alrededor de la hora 18, así que las 28,7 horas no significan que todos los agentes trabajaran sin interrupciones desde el principio hasta el final.

Además, las 47 proposiciones aparcadas temporalmente no son lo mismo que los 47 lemas de la entrada predefinida. No hay que confundirlos al leer la documentación oficial.

Langlands–Tunnell: 750 agentes se unen para superar el obstáculo más difícil de la formalización del último teorema de Fermat

Al acercarse al final, el equipo se encontró con el obstáculo más difícil: las proposiciones relacionadas con Langlands–Tunnell, un resultado matemático importante en la ruta de demostración de Wiles. Al principio, el agente encargado de esta parte estimó que podía requerir entre 700.000 y 1.000.000 de líneas de código Lean, y consideró que la probabilidad de completarla en el tiempo restante era inferior al 1 %.

Después, Lead concentró en esta tarea a unos 750 agentes Helper. Los agentes crearon por su cuenta un árbol de tareas con varios niveles:

• Se dividió en 10 áreas principales.
• Se crearon 2.418 subtareas.
• El árbol de tareas alcanzó una profundidad de 10 niveles.
• Cientos de agentes trabajaron a la vez en distintas subtareas.

Langlands–Tunnell se completó en la hora 28,4, y el último teorema de Fermat, 0,3 horas después. Este caso muestra que el valor del paralelismo a gran escala no se reduce a que «muchas personas calculen más rápido». Lo fundamental es descomponer un problema demasiado grande para abordarlo directamente en muchas tareas pequeñas que puedan avanzar de forma independiente, verificarse por separado y combinarse al final. Si la descomposición no se hace bien, los 750 agentes solo se quedarán esperando unos a otros o repetirán el mismo trabajo.

Por qué tuvo éxito la formalización del último teorema de Fermat: verificación de Lean y medidas de seguridad

Desde el punto de vista de la fiabilidad de ingeniería, el experimento se apoyó en tres capas de protección.

La primera capa fue la verificación de los resultados. Cada subproposición tenía que superar la comprobación de Lean antes de incorporarse a la rama principal. La tabla Landed solo registraba el trabajo que había pasado esa comprobación. La prueba final fue verificada por el comprobador oficial del kernel. Lead Agent dejó constancia de lo siguiente: «El último teorema de Fermat está en la rama principal, verificado por el comprobador oficial del kernel».

La segunda capa fue el aislamiento durante la colaboración. Los entornos aislados y las ramas de Git independientes redujeron al mínimo los conflictos entre archivos y las interferencias entre agentes.

La tercera capa fueron los límites de seguridad. El experimento utilizó un modelo temprano cuya evaluación de alineación aún no había concluido antes de su lanzamiento oficial. Por eso, Anthropic estableció varias restricciones:

• Se prohibió el acceso a Internet y el acceso directo a los entornos aislados de otros agentes.
• Los comandos se ejecutaron con cuentas sin privilegios.
• Un Gateway externo gestionó las comunicaciones con la API, Git y la base de datos.
• Un clasificador en tiempo real comprobó los comandos de Shell y las modificaciones de archivos, mientras que un monitor fuera de línea revisó los registros de operaciones.

El experimento generó más de un millón de llamadas a herramientas, y ninguna llegó al nivel que exigía bloquearla. Anthropic también indicó que, después del experimento, añadió un sistema paralelo de supervisión de la cadena de pensamiento. La conclusión es que, para evaluar un sistema de agentes fiable, no basta con comprobar si el modelo puede completar la tarea: también hacen falta verificación independiente, límites de permisos y un entorno de ejecución rastreable.

De 11 días a 28,7 horas: comparación de dos experimentos de Claude Fable 5.2

Los dos experimentos de formalización del último teorema de Fermat emplearon criterios distintos, así que conviene analizarlos por separado:

Cabe destacar que los 6000 millones de tokens, los 13 millones de líneas de código y los aproximadamente 30.300 teoremas corresponden al primer experimento. La empresa no ha publicado cifras absolutas de tokens, el costo total ni el número exacto de líneas de código del segundo experimento.

Al principio, el primer experimento también tuvo algunos tropiezos: a los agentes les costaba mantener una visión global del estado, no sabían qué habían terminado los demás y duplicaban trabajo. Más adelante se incorporó la plataforma Prove2Me, que usaba un DAG para gestionar las dependencias entre teoremas y ofrecía seguimiento del estado de las tareas, búsqueda de teoremas y compilación acelerada. El cambio en el segundo experimento fue dejar de usar esa plataforma especializada y permitir que los agentes crearan sus propios mecanismos de colaboración con una base de datos genérica y Git. Cinco tablas desempeñaban funciones similares.

Anthropic también hizo una comparación con la misma configuración de 1000 agentes: Opus 5.5 completó alrededor del 26 % en 18 horas y, para las 30 horas, apenas había avanzado; Fable 5.2 completó la prueba final en 28,7 horas. Ambos equipos reanudaron el trabajo desde un estado guardado alrededor de las 18 horas. Sin embargo, cada modelo se ejecutó una sola vez, por lo que estos resultados no permiten concluir que haya una diferencia general entre ambos para todo tipo de tareas complejas.

Análisis del impacto de 1000 experimentos con agentes de IA en las empresas

Para desarrolladores: cuatro capacidades clave de los sistemas multiagente

Si dejamos de lado las matemáticas, las capacidades que revela este experimento se pueden relacionar con situaciones empresariales habituales:

La lección más práctica para los desarrolladores es que no hace falta empezar construyendo una plataforma especializada y compleja: una base de datos compartida bien diseñada, junto con control de versiones, puede sostener colaboraciones de una escala considerable. Este es un ejemplo mínimo de invocación del modelo:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Interfaz unificada de APIYI
)

response = client.chat.completions.create(
    model="claude-fable-5-2",  # Consulta la lista de modelos de la plataforma para ver los nombres disponibles
    messages=[{"role": "user", "content": "把这个任务拆成可独立验证的子任务"}]
)
print(response.choices[0].message.content)

import sqlite3
import openai

# SQLite se usa aquí para simular localmente las tablas Subtasks / Landed del experimento (en el experimento se usó PostgreSQL)
db = sqlite3.connect("board.db")
db.execute("CREATE TABLE IF NOT EXISTS subtasks (id INTEGER PRIMARY KEY, goal TEXT, status TEXT, owner TEXT)")
db.execute("CREATE TABLE IF NOT EXISTS landed (task_id INTEGER, result TEXT)")

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

def lead_plan(goal: str):
    """Lead: descompone la tarea y la añade a la cola."""
    resp = client.chat.completions.create(
        model="claude-fable-5-2",
        messages=[{"role": "user", "content": f"将目标拆为3-5个子任务,每行一个:{goal}"}]
    )
    for line in resp.choices[0].message.content.splitlines():
        if line.strip():
            db.execute("INSERT INTO subtasks (goal, status) VALUES (?, 'open')", (line.strip(),))
    db.commit()

def verify(result: str) -> bool:
    """Verificador independiente: en un caso real, debería sustituirse por pruebas, un script de validación o una comprobación de Lean."""
    return len(result) > 0

def helper_claim(name: str):
    """Helper: reclama una tarea y solo la registra en landed si supera la verificación."""
    row = db.execute("SELECT id, goal FROM subtasks WHERE status='open' LIMIT 1").fetchone()
    if not row:
        return
    task_id, goal = row
    db.execute("UPDATE subtasks SET status='doing', owner=? WHERE id=?", (name, task_id))
    db.commit()
    resp = client.chat.completions.create(
        model="claude-fable-5-2",
        messages=[{"role": "user", "content": goal}]
    )
    result = resp.choices[0].message.content
    if verify(result):
        db.execute("INSERT INTO landed VALUES (?, ?)", (task_id, result))
        db.execute("UPDATE subtasks SET status='done' WHERE id=?", (task_id,))
    else:
        db.execute("UPDATE subtasks SET status='open', owner=NULL WHERE id=?", (task_id,))
    db.commit()

lead_plan("为一个开源库补全单元测试")
for i in range(3):
    helper_claim(f"helper-{i}")

🚀 Consejo para empezar: si quieres reproducir un prototipo pequeño con «descomposición por Lead + asignación por Helper + verificación independiente», puedes empezar solicitando una cuota de prueba gratuita en APIYI, en apiyi.com. La plataforma ofrece una interfaz compatible con OpenAI; con una sola clave puedes cambiar entre modelos como Claude, GPT y Gemini, y comparar la calidad de la descomposición cuando distintos modelos actúan como Lead.

Para el sector: los límites importan más que las cifras

Conviene tener presente un aspecto: la formalización matemática cuenta con verificadores estrictos y objetivos como Lean, pero la mayoría de las tareas empresariales no tienen criterios de corrección igual de claros. El código puede respaldarse con pruebas, pero a menudo es difícil determinar automáticamente si un análisis de mercado o un proceso interdepartamental es «correcto». Por eso, las 28.7 horas y la tasa de éxito de este experimento no se pueden extrapolar directamente a los sistemas Agent empresariales.

Anthropic también señala varias limitaciones: los Agent pueden concluir demasiado pronto que una tarea es imposible. Por ejemplo, de las 47 proposiciones que se dejaron de lado al principio, la mayoría se acabó resolviendo. La orientación de las personas sigue siendo valiosa en los momentos difíciles, y herramientas especializadas en un dominio, como Prove2Me, aún podrían mejorar la compilación, la recuperación de información y la colaboración. El experimento no demuestra que cuantos más Agent haya, mejor, ni que ya no hagan falta expertos humanos y Harness especializados.

💡 Recomendación de ingeniería: Al probar soluciones multiagente en una empresa, conviene empezar por tareas con criterios de verificación claros, como cambios de código guiados por pruebas, y ampliar el alcance poco a poco. Con la facturación por uso de APIYI (apiyi.com), se puede empezar con un número reducido de Agent para evaluar las etapas de descomposición y verificación, y después decidir si merece la pena aumentar la inversión.

Preguntas frecuentes

Conclusiones clave: 1000 agentes de IA formalizan el último teorema de Fermat

• En qué consistió el experimento: formalizar una demostración existente en código verificable por Lean; no demostrar por primera vez el último teorema de Fermat.
• Cifras clave: 1000 agentes de la versión preliminar de Fable 5.2 lo completaron en 28,7 horas y superaron la verificación del núcleo oficial de Lean.
• Organización central: 1 Lead y 999 Helper colaboraron mediante cinco tablas de base de datos compartidas y Git.
• Cómo abordaron el reto: unos 750 agentes descompusieron Langlands–Tunnell en 2418 subtareas, con una profundidad máxima de 10 niveles.
• De dónde viene la fiabilidad: verificación independiente de Lean y aislamiento en un entorno seguro; no hizo falta bloquear ninguna de las más de un millón de llamadas a herramientas.
• Límites de aplicación: en las tareas empresariales suele faltar un verificador como Lean, por lo que no se pueden extrapolar directamente estas cifras de eficiencia.
• Cómo empezar: con la interfaz unificada de APIYI apiyi.com se puede reproducir a pequeña escala un prototipo de colaboración entre Lead y Helper.

Resumen

Estos son los puntos centrales del experimento de los mil agentes de Claude Fable 5.2:

1. El sistema importa más que un elemento aislado: la capacidad del modelo, la descomposición de tareas, el estado compartido, la ejecución en paralelo y la verificación automática contribuyeron al resultado de 28,7 horas.
2. La verificación es la base de la confianza: la comprobación del núcleo de Lean permite distinguir rigurosamente entre «el modelo afirma que ha terminado» y «la tarea está realmente terminada».
3. Hay que dejar claros los límites: los datos de entrada predefinidos, el uso de un modelo preliminar, la comparación de una sola ejecución y el carácter de experimento de juguete impiden interpretar el resultado de forma exagerada.

Este experimento deja sobre la mesa una pregunta importante para el sector: ¿la competencia de los sistemas de IA está pasando de las capacidades de un único modelo a la capacidad de organizar y coordinar numerosos agentes para resolver tareas complejas? Los desarrolladores pueden empezar probando un pequeño prototipo multiagente con verificación independiente. APIYI apiyi.com permite comprobar rápidamente los resultados con crédito gratuito para pruebas y una interfaz unificada para varios modelos.

📚 Referencias

1. Blog de ingeniería de Anthropic: Safely scaling multi-agent teams with Claude Fable 5.2
2. Enlace: claude.dev/blog/safely-scaling-multi-agent-teams-with-fable-5-2

3. Descripción: organización del equipo, colaboración con bases de datos, mecanismos de seguridad y comparación con Opus en el segundo experimento

4. Artículo de investigación de Anthropic: Formalizing Fermat’s Last Theorem

5. Enlace: anthropic.com/research/formalizing-fermats-last-theorem

6. Descripción: datos del primer experimento de formalización y método de colaboración con Prove2Me

7. Repositorio oficial de pruebas de Lean de Anthropic: primera versión de la prueba formal

8. Enlace: github.com/anthropics/fermats-last-theorem

9. Descripción: código de prueba de la versión pública de septiembre; los datos del README no coinciden con las estadísticas del experimento de noviembre

10. Caso de uso oficial de Lean: Formalizing Fermat’s Last Theorem

11. Enlace: lean-lang.org/use-cases/flt

12. Descripción: información sobre Lean y los fundamentos de las matemáticas formales

13. Documentación del modelo Fable 5.2: especificaciones del modelo y migración de API

14. Enlace: platform.claude.com/docs/en/models/fable-5-2/overview
15. Descripción: ventana de contexto, límite de salida e información sobre precios

Autor: equipo técnico de APIYI
Intercambio técnico: puedes contactarnos desde la página de inicio de APIYI. Encontrarás más recursos en el centro de documentación docs.apiyi.com.

Artículos relacionados

• Lanzamiento de Claude Fable 5.2: ¿high o max? Veamos los datos y comparemos la calidad y el costo.: Las evaluaciones públicas muestran que elevar el nivel de razonamiento de Claude Fable 5.2 de high a max puede mejorar la puntuación, pero también aumentar el coste por tarea; el nivel debe elegirse teniendo en cuenta tanto los requisitos de calidad como el presupuesto.
• Claude Fable 5.2 frente a Claude Opus 5.5: ¿cuál elegir?: Claude Fable 5.2 frente a Claude Opus 5.5: el precio estándar cuesta el doble, pero no gana en todos los aspectos; este artículo ofrece una tabla para elegir el modelo según la tarea desde cuatro perspectivas: especificaciones, precios, nivel de esfuerzo predeterminado y resultados en pruebas de lanzamiento.
• ¿Qué tan potente es Claude Fable 5.2? 4 límites en programación y tareas largas: Explica, con los resultados y límites oficiales del artículo publicado por Anthropic, en qué destaca Claude Fable 5.2, hasta dónde conviene usarlo y cuándo no conviene cambiar de Opus 5.5.
• Un backend de Git listo para producción en 10 semanas: las 5 claves de ingeniería con las que OpenAI logró que su equipo de agentes Codex completara Pando: Análisis de OpenAI Pando: un ingeniero diseñó el núcleo, varios equipos de agentes Codex lo implementaron y unos pocos ingenieros lo desplegaron en producción en 10 semanas, con especial atención al sistema de pruebas, la migración gradual y los métodos aplicables.