Cortex.0

Présentation

Cortex.0 est un modèle d'intelligence artificielle conçu par Frankenstein-Labs, sous la direction d'Abdoulaye Coumbassa (16 ans, créateur guinéen).

Ce modèle est spécialisé dans un domaine unique : l'informatique.

Il ne cherche pas à tout faire. Il ne cherche pas à être bon partout. Il fait une seule chose, et il la fait bien : écrire, lire, corriger et expliquer du code.

Cortex.0 est né d'une idée simple : un modèle n'a pas besoin de connaître la poésie, la philosophie ou l'histoire pour être utile à un développeur. Il a besoin de comprendre le code. C'est ce pour quoi il a été construit, et c'est ce pour quoi il est bon.

Le créateur

Abdoulaye Coumbassa, 16 ans, créateur guinéen, est à l'origine de ce modèle. Cortex.0 est un modèle guinéen et francophone, développé par Frankenstein-Labs.

C'est un projet africain. Il montre qu'un modèle spécialisé, entraîné avec des moyens limités, peut rendre de vrais services sur un domaine précis, sans avoir besoin des moyens d'un grand laboratoire.

Ce qu'il sait faire

Cortex.0 est taillé pour le code et le développement :

• Écrire du code — fonctions, classes, scripts, algorithmes
• Lire et analyser le code source — comprendre un fichier existant
• Corriger des bugs — trouver la cause et proposer la correction
• Expliquer des programmes — décrire ce que fait le code, ligne par ligne
• Écrire des tests — tests unitaires et cas limites
• Analyser une base de code — suivre les appels, repérer les dépendances
• Utiliser la ligne de commande — commandes shell, scripts, outils
• Raisonner sur des problèmes techniques — décomposer, comparer, décider
• Refactoriser — simplifier et nettoyer du code existant
• Documenter — écrire des commentaires et des docstrings

Langues supportées

• Français — Langue principale et domaine de prédilection, où il offre ses meilleurs résultats. C'est la langue de travail du modèle.
• Anglais / Chinois — Compréhension de base limitée. Ce n'est pas son domaine principal. Il comprend un peu, mais il ne faut pas compter sur lui pour ces langues.

Résultats

Les résultats ci-dessous portent sur les tâches d'informatique et de génération de code. Ce sont les tâches pour lesquelles le modèle a été conçu.

Génération de code

Tâche	Résultat
Écrire une fonction à partir d'une description	Très bon
Écrire un script complet	Très bon
Écrire des tests unitaires	Bon
Compléter du code existant	Très bon
Traduire une idée en code	Très bon

Correction et analyse

Tâche	Résultat
Trouver un bug dans une fonction	Très bon
Expliquer un code inconnu	Très bon
Proposer une correction	Bon
Suivre un appel à travers plusieurs fichiers	Bon
Repérer une erreur de logique	Bon

Comparaison

Cortex.0 est un modèle spécialisé, avec environ 40 milliards de paramètres. Sur les tâches d'informatique, il se rapproche des grands modèles généralistes comme les modèles OpenAI, alors qu'il est bien plus petit et bien plus spécialisé.

Domaine	Cortex.0	Modèles généralistes (OpenAI)
Écriture de code	Très bon	Très bon
Explication de code	Très bon	Très bon
Correction de bugs	Bon	Très bon
Français technique	Très bon	Bon
Conversation générale	Faible	Très bon
Littérature et poésie	Faible	Très bon
Philosophie et histoire	Faible	Très bon
Sciences fondamentales	Faible	Bon

Sur son domaine, Cortex.0 rivalise. Hors de son domaine, il ne rivalise pas, et il ne le prétend pas.

Points forts

• Le français technique : vocabulaire précis, phrases claires, pas de mélange avec l'anglais.
• L'explication de code : il décrit ce que fait un programme sans se perdre.
• L'écriture de code : il produit du code lisible et structuré.
• La taille : un modèle spécialisé, léger, qui peut tourner localement.

Points faibles

• La conversation générale : hors informatique, il n'est pas fiable.
• La création de contenu : histoires, poésie, chansons — ce n'est pas son domaine.
• Les sciences fondamentales : mathématiques avancées, physique, chimie.
• L'anglais et le chinois : compréhension limitée.

Ce qu'il ne fait pas

Ce modèle n'est pas conçu pour :

• la conversation générale
• la littérature
• la philosophie
• les langues
• les sciences fondamentales (mathématiques avancées, physique, chimie)
• la création de contenu (histoires, poésie, chansons)
• la traduction
• les conseils personnels
• toute autre tâche hors du domaine informatique

Si vous lui demandez autre chose que de l'informatique, il ne sera pas bon. Ce n'est pas son domaine. Ce n'est pas ce pour quoi il a été fait. Ce n'est pas ce pour quoi il a été entraîné.

Techniques d'information

• Créateur : Abdoulaye Coumbassa (Frankenstein-Labs)
• Origine : Modèle guinéen / français
• Architecture : silex
• Paramètres : 40B
• Format : GGUF (Q8_0)
• Taille du fichier : 39,40 Gio
• Contexte : 262 144 jetons
• Quantification : Q8_0
• Licence : MIT

Utilisation

# llama.cpp
llama-cli -hf Frankenstein-Labs/Cortex.0 --hf-file Cortex.0-Q8_0.gguf -p "Écris une fonction Python"

# serveur compatible OpenAI
llama-server -hf Frankenstein-Labs/Cortex.0 --hf-file Cortex.0-Q8_0.gguf --port 8080

Paramètres de génération recommandés

Paramètre	Valeur
Température	1.0
Top-p	0.95
Top-k	20
Budget de sortie	au moins 32 768 jetons

Limites

• Modèle spécialisé : les performances hors informatique ne sont pas garanties.
• Le code généré doit être testé et relu avant utilisation.
• Un long raisonnement augmente la latence.
• Le contexte maximal est une limite de capacité, non une garantie d'exactitude.

En résumé

Cortex.0 est un modèle guinéen et africain, créé par Abdoulaye Coumbassa pour Frankenstein-Labs. Il est spécialisé en français et en informatique. Il sait écrire du code, lire du code, corriger des bugs et expliquer des programmes. Sur son domaine, il se rapproche des grands modèles. Pour tout le reste, il n'est pas puissant.

---

Intégration OpenHands

Cortex.0 est branché au SDK OpenHands comme moteur de raisonnement de la boucle d'action-perception. Le modèle n'est pas un outil appelé de l'extérieur : c'est le llm que le SDK consulte à chaque tour, et les outils du SDK (terminal, éditeur de fichiers, task tracker, glob, grep) forment son espace d'action.

Boucle d'événements OpenHands
        │  observation
        ▼
   Agent (SDK) ──chat/completions──▶ serveur d'inférence Cortex.0
        │                                    │
        │◀──────── tool_calls ───────────────┘
        ▼
  sandbox : terminal · fichiers · navigateur

Statut

Validé de bout en bout : un vrai point d'accès compatible OpenAI, le vrai SDK, une vraie boucle d'agent. Le test a produit un ActionEvent, un ObservationEvent (l'outil terminal a réellement exécuté dans le sandbox) et un MessageEvent final.

Installation

pip install -r requirements.txt

Lancer le serveur d'inférence

Le modèle demande environ 45 Gio de RAM en Q8_0, ou un GPU de 48 Go de VRAM.

# llama.cpp — le plus simple
./scripts/serve_llamacpp.sh Cortex.0-Q8_0.gguf 8080

# SGLang — meilleur débit pour cette architecture MoE
./scripts/serve_sglang.sh RecursiveSI/flint 8080

Utilisation

# vérifier le point d'accès, puis s'arrêter
python3 -m cortex0.cli --check

# lancer une tâche
python3 -m cortex0.cli "Corrige le bug dans utils.py et lance les tests"

from cortex0 import Cortex0Agent, Cortex0Settings

settings = Cortex0Settings.load()
settings.base_url = "http://127.0.0.1:8080/v1"

agent = Cortex0Agent(settings=settings)   # sonde le serveur, puis construit l'agent
print(agent.summary())
agent.run("Écris un serveur HTTP en Python et teste-le.")

Configuration

Modifiez configs/cortex0.yaml. Chaque champ peut être remplacé par une variable d'environnement CORTEX0_<CHAMP> :

CORTEX0_BASE_URL=http://gpu:8080/v1 CORTEX0_TEMPERATURE=0.7 python3 -m cortex0.cli --check

Champ	Défaut	Rôle
base_url	http://127.0.0.1:8080/v1	point d'accès Cortex.0
served_model_name	cortex0	nom servi par le point d'accès
model	openai/cortex0	nom utilisé par litellm
temperature	1.0	recommandé pour ce modèle
top_p / top_k	0.95 / 20	recommandés pour ce modèle
max_output_tokens	32768	le raisonnement long a besoin de marge
tools	terminal, file_editor, task_tracker, glob, grep	espace d'action du modèle
native_tool_calling	true	utilise le protocole d'outils du modèle
num_retries	5	survit à un incident réseau ou sandbox

Robustesse

• probe_server() vérifie /models, puis le chat, puis un vrai aller-retour d'appel d'outil avant que l'agent soit construit : un point d'accès cassé échoue avec un message clair au lieu d'une trace au milieu d'une exécution.
• Si le point d'accès répond mais n'émet aucun tool_calls, l'intégration avertit que le modèle n'est peut-être pas entraîné aux outils, au lieu de prétendre le contraire.
• num_retries absorbe les défaillances transitoires du sandbox.
• Un condenseur résumant garde les longues sessions dans la fenêtre de contexte.

Performance

Changer le nombre d'experts MoE actifs ne rend pas le modèle plus fort. C'est mesuré sur un vrai modèle MoE : passer de 8 à 15 experts tourne 1,43 fois plus lentement, et 64 experts plantent par manque de mémoire. Le nombre d'experts est une propriété apprise, pas un réglage.

Voir docs/experts.md pour les mesures et pour ce qui améliore réellement le système. Pour reproduire sur n'importe quel GGUF MoE :

python3 scripts/experiments/bench_experts.py Cortex.0-Q8_0.gguf --experts 2,6,15

Arborescence

cortex0/
  settings.py   configuration, YAML + environnement
  llm.py        lie le SDK au point d'accès Cortex.0
  health.py     sonde : joignable, chat, appels d'outils
  agent.py      construit l'agent et enregistre les outils
  fusion.py     Cortex0Agent — le système unifié
  cli.py        ligne de commande
prompts/
  cortex0_system.txt   prompt système de l'agent
configs/
  cortex0.yaml         configuration par défaut
scripts/
  serve_llamacpp.sh    servir avec llama.cpp
  serve_sglang.sh      servir avec SGLang
  experiments/
    bench_experts.py   mesure l'effet du nombre d'experts
tests/
  fake_server.py       serveur compatible OpenAI de substitution
  test_fusion.py       validation de bout en bout
docs/
  experts.md           mesures sur les experts

Ce que ce n'est pas

Ceci est l'intégration. Elle ne rend pas le modèle lui-même plus puissant : changer les capacités d'un modèle demande de l'entraînement, donc des GPU. Si les appels d'outils sont faibles en pratique, le modèle doit être affiné sur des trajectoires d'usage d'outils.

Test

python3 tests/test_fusion.py