Proposition : Ulias Org v4 — Projet Separe + CLI Live

Date : 12/02/2026 14:00 Priorite : HAUTE Status : EN ATTENTE DE VALIDATION Base : 12-02-2026-03-30-agent-autonome-devstral.md (v3)

Changements v3 → v4

ulias-org = projet GitLab separe (pas un sous-module de ai-orchestrator)
CLI terminal live style Claude Code (interface principale du CEO)
Web UI chat + dashboard (complement navigateur)
Frontiere claire entre ai-orchestrator (GPU backend) et ulias-org (agent orchestration)

Tout le reste de la v3 (equipes, agents, Context Builder, apprentissage, schema DB) reste inchange.

1. Separation des projets

Pourquoi separer

ai-orchestrator est un backend GPU generaliste : il recoit des jobs (chat, image, video, audio), les dispatche sur les GPUs, et retourne les resultats. Il ne sait rien des agents, des equipes, du raisonnement multi-etapes.

ulias-org est un orchestrateur d'agents intelligent : il raisonne, decompose, coordonne, apprend. Il a besoin d'un LLM pour penser — il appelle ai-orchestrator pour ca, comme n'importe quel autre client.

┌─────────────────────────────────────────────────────────────────┐
│                        ULIAS-ORG                                │
│                                                                  │
│  ┌──────┐ ┌──────────┐ ┌────────────┐ ┌───────────────────┐    │
│  │ CLI  │ │  Web UI  │ │  Director  │ │  26 micro-agents  │    │
│  │ live │ │ chat+dash│ │  Generale  │ │  (7 equipes)      │    │
│  └──┬───┘ └────┬─────┘ └─────┬──────┘ └────────┬──────────┘    │
│     │          │              │                   │               │
│     └──────────┴──────┬──────┴───────────────────┘               │
│                       │                                          │
│              ┌────────┴────────┐                                 │
│              │  Agent Runner   │                                 │
│              │  Context Builder│                                 │
│              │  Pipelines      │                                 │
│              └────────┬────────┘                                 │
└───────────────────────┼──────────────────────────────────────────┘
                        │
          ┌─────────────┼─────────────────────────┐
          │             │                         │
          ▼             ▼                         ▼
   ┌────────────┐ ┌──────────┐  ┌──────────────────────┐
   │AI-ORCHEST. │ │ Supabase │  │ Infra (SSH, Docker,  │
   │            │ │          │  │ GitLab, Loki, etc.)  │
   │ POST /api/ │ │ agents.* │  │                      │
   │   jobs     │ │ tables   │  │ via connectors-api   │
   │            │ │          │  │ ou SSH direct         │
   │ GPU0: 3090 │ │ pgvector │  │                      │
   │ GPU1: 2070S│ │          │  │                      │
   └────────────┘ └──────────┘  └──────────────────────┘

Communication ulias-org → ai-orchestrator

Chaque fois qu'un agent a besoin du LLM, ulias-org fait :

// Agent Runner appelle ai-orchestrator pour inferer
const response = await fetch('https://ai-orchestrator.33800.nowhere84.com/api/jobs', {
  method: 'POST',
  body: JSON.stringify({
    tool_id: 'ollama',           // ou 'ollama-gpu1'
    job_type: 'chat',
    priority: 0,
    input_params: {
      model: 'devstral-small-2', // ou 'qwen3-coder-next'
      messages: contextBuilder.build(agent, task),
      tools: agent.tools,        // tool definitions pour tool calling
      temperature: 0.1,
      stream: false
    },
    callback_url: 'https://ulias-org.33800.nowhere84.com/api/internal/job-complete'
  })
});

Mode synchrone (agent attend la reponse) : poll /api/jobs/{id} toutes les 500ms Mode callback (agent non-bloquant) : callback_url notifie quand le job est fini

Deux repos, deux containers

	ai-orchestrator	ulias-org
Repo	gouroubleu/ai-orchestrator	gouroubleu/ulias-org
Runtime	Python 3.12 (FastAPI)	Bun (TypeScript, Elysia)
Domaine	ai-orchestrator.33800	ulias-org.33800
Port	5501	5510
Target	prod-portainer	prod-portainer
Responsabilite	GPU dispatch, job queue	Agent orchestration, raisonnement
Base de donnees	ai_jobs (Supabase)	agents.* (Supabase)

2. CLI Live — L'interface principale

Vision

Le CEO lance ulias dans son terminal et parle a l'organisation. Comme Claude Code, mais c'est l'org qui repond — pas un modele unique.

$ ulias

  ╭─────────────────────────────────────────────╮
  │  Ulias Org v0.1.0                           │
  │  7 equipes · 26 agents · 2 GPUs            │
  │  Status: operationnel                       │
  ╰─────────────────────────────────────────────╯

  3 objectifs en cours · 1 decision en attente

CEO > le deploy de connectors-api a casse, fix stp

  ⠋ Interpreter analyse le message...
  ✓ Compris : "connectors-api deploy broken, need fix"

  ⠋ Director decompose l'objectif...
  ✓ Objectif #87 cree : "Fix connectors-api post-deploy"
    → Equipe Ops (Incident) + Ingenierie (Coder)

  ⠋ Incident diagnostique...
    │ Checking container status...
    │ connectors-api: restarting (exit code 1)
    │ Logs: "TypeError: Cannot read property 'get' of undefined"
    │ Last commit: a]4f2e1 "refactor: move headers to middleware"
    │ Root cause: headers.get() called on plain object (known bug pattern)
  ✓ Diagnostic complet — bug connu (Elysia headers)

  ⠋ Coder prepare le fix...
    │ Reading src/middleware/auth.ts...
    │ Applying getHeader() pattern (lesson from 4ffeb3e)
    │ Edit: line 42 — headers.get('x-api-key') → getHeader(headers, 'x-api-key')
  ✓ Fix pret — 1 fichier, 3 lignes modifiees

  ⠋ Reviewer verifie...
  ✓ Review OK — pattern correct, pas de regression

  ⚠ Decision requise :
    Deployer directement ? (confidence: 0.89)
    [Y] Oui, deploy    [N] Non, je review d'abord    [D] Diff

CEO > y

  ⠋ Deployer push + deploy...
    │ git commit -m "fix: use getHeader() for Elysia headers in auth middleware"
    │ git push origin main
    │ Pipeline started...
    │ Build: OK (23s)
    │ Deploy: OK (18s)
    │ Health: OK (200)
  ✓ connectors-api deploye et healthy

  ✓ Objectif #87 COMPLETE (2m 34s)
    Lecon enregistree: "auth middleware avait le meme bug headers.get()"

CEO >

Architecture technique du CLI

┌──────────────────────────────────────────────────┐
│                   CLI (Bun)                       │
│                                                   │
│  ┌─────────────┐  ┌──────────────┐  ┌─────────┐ │
│  │   Readline   │  │  Renderer    │  │  State  │ │
│  │   (input)    │  │  (output)    │  │  Store  │ │
│  │              │  │              │  │         │ │
│  │  - prompt    │  │  - markdown  │  │ - tasks │ │
│  │  - history   │  │  - spinners  │  │ - agents│ │
│  │  - autocmpl  │  │  - colors   │  │ - logs  │ │
│  │  - shortcuts │  │  - streaming│  │         │ │
│  └──────┬───────┘  └──────▲──────┘  └────┬────┘ │
│         │                 │               │      │
│         └─────────┬───────┴───────────────┘      │
│                   │                               │
│         ┌─────────▼──────────┐                   │
│         │   WebSocket Client │                   │
│         │                    │                   │
│         │  wss://ulias-org.  │                   │
│         │  33800.../ws/cli   │                   │
│         └────────────────────┘                   │
└──────────────────────────────────────────────────┘
                    │
                    │ WebSocket (streaming bidirectionnel)
                    │
┌───────────────────▼──────────────────────────────┐
│              ULIAS-ORG SERVER                      │
│                                                    │
│  /ws/cli endpoint (Elysia WebSocket)               │
│                                                    │
│  Messages entrants (CEO → Org) :                   │
│  - { type: "message", content: "..." }             │
│  - { type: "decision", choice: "Y" }               │
│  - { type: "command", cmd: "status" }              │
│                                                    │
│  Messages sortants (Org → CEO) :                   │
│  - { type: "thinking", agent: "Incident", text }   │
│  - { type: "step", agent: "Coder", text }          │
│  - { type: "decision_request", options: [...] }    │
│  - { type: "complete", objective_id, summary }     │
│  - { type: "error", message }                      │
└────────────────────────────────────────────────────┘

Fonctionnalites CLI

Fonctionnalite	Description
Chat libre	Taper un message → l'Interpreter traduit → l'Org execute
Streaming	Voir chaque agent travailler en temps reel (spinners, logs)
Decisions inline	Repondre Y/N/choix directement dans le terminal
Commandes /	`/status`, `/teams`, `/objectives`, `/logs`, `/cancel`, `/pause`
Historique	Fleches haut/bas, recherche dans l'historique
Autocompletion	Noms d'agents, services, commandes
Markdown	Rendu inline (gras, code, listes)
Mode watch	`ulias --watch` : flux continu des actions de l'org
Mode headless	`ulias run "fix connectors-api"` : lancer et quitter

Commandes slash

/status              — Vue d'ensemble : equipes, agents, objectifs en cours
/teams               — Detail par equipe (agents, metriques)
/objectives          — Liste objectifs (pending, in_progress, completed)
/objective <id>      — Detail d'un objectif + arbre de taches
/logs [agent]        — Logs temps reel (tous ou filtre par agent)
/cancel <id>         — Annuler un objectif
/pause               — Mettre l'org en pause (plus de taches proactives)
/resume              — Reprendre
/decide <id> <choix> — Repondre a une decision en attente
/metrics             — Metriques globales (taux autonomie, tokens, etc.)
/memory <query>      — Chercher dans la memoire collective
/config              — Preferences CLI (couleurs, verbosity, notifications)

Package et installation

# Installation globale via bun
bun install -g @ulias/cli

# Ou lien direct depuis le repo
cd ulias-org && bun link

# Lancement
ulias                    # Mode interactif
ulias run "deploy X"     # Mode one-shot
ulias --watch            # Mode observation
ulias status             # Quick status (pas de session interactive)

Le CLI est un package dans le monorepo ulias-org (pas un repo separe) :

ulias-org/
├── packages/
│   ├── cli/                 # CLI terminal
│   │   ├── src/
│   │   │   ├── index.ts     # Entry point
│   │   │   ├── renderer.ts  # Terminal output (colors, spinners, markdown)
│   │   │   ├── input.ts     # Readline, history, autocompletion
│   │   │   ├── ws-client.ts # WebSocket vers le serveur
│   │   │   ├── commands/    # Handlers /status, /teams, etc.
│   │   │   └── config.ts    # ~/.ulias/config.json
│   │   ├── bin/
│   │   │   └── ulias.ts     # #!/usr/bin/env bun
│   │   └── package.json
│   └── server/              # Backend Elysia (container Docker)
│       ├── src/
│       │   ├── index.ts
│       │   ├── ws/
│       │   │   ├── cli.ts       # WebSocket handler CLI
│       │   │   └── webui.ts     # WebSocket handler Web UI
│       │   ├── director/
│       │   ├── teams/
│       │   ├── context-builder/
│       │   ├── agent-runner/
│       │   ├── pipelines/
│       │   ├── tools/
│       │   ├── communication/
│       │   ├── models/
│       │   │   ├── ollama.ts    # Client ai-orchestrator
│       │   │   └── claude.ts    # Fallback Claude API
│       │   └── db/
│       ├── prompts/             # 26 fichiers prompt (1 par agent)
│       └── package.json
├── apps/
│   └── web-ui/              # App Qwik (dashboard + chat navigateur)
│       ├── src/
│       │   ├── routes/
│       │   │   ├── index.tsx        # Dashboard principal
│       │   │   ├── chat/            # Chat live (comme le CLI mais web)
│       │   │   ├── objectives/      # Liste + detail objectifs
│       │   │   ├── decisions/       # Decisions en attente
│       │   │   ├── teams/           # Vue equipes + agents
│       │   │   ├── metrics/         # Grafana-like metriques
│       │   │   └── memory/          # Exploration memoire collective
│       │   └── components/
│       │       ├── terminal.tsx     # Composant terminal (xterm.js)
│       │       ├── agent-card.tsx
│       │       ├── objective-tree.tsx
│       │       └── decision-modal.tsx
│       └── package.json
├── Dockerfile
├── conf.prod.gouroubleu.yml
├── bun.lockb
└── package.json             # Workspace root

3. Web UI — Le complement navigateur

La Web UI couvre ce que le CLI ne peut pas faire confortablement :

Pages

Page	Contenu
Dashboard	Vue d'ensemble : agents actifs, objectifs, metriques temps reel, sante GPUs
Chat	Terminal web (xterm.js) — meme experience que le CLI, dans le navigateur
Objectifs	Liste, detail, arbre de taches, timeline
Decisions	File d'attente des decisions CEO, avec contexte + options
Equipes	Cartes agents, metriques par equipe, logs filtres
Metriques	Taux autonomie, tokens/jour, confiance, escalades, historique
Memoire	Recherche semantique dans la memoire collective, lecons recentes

Techniquement

Framework : Qwik (coherent avec connectors-front)
WebSocket : meme serveur WS que le CLI, endpoint /ws/webui
Realtime : Supabase Realtime pour les updates DB (objectifs, taches, decisions)
Domaine : https://ulias-org.33800.nowhere84.com (le serveur sert l'API + la Web UI)
Terminal web : xterm.js pour le mode chat (meme rendu que le CLI)

4. conf.prod.gouroubleu.yml

name: "ulias-org"
target: "prod-portainer"
type: "bun"
domain: "ulias-org.33800.nowhere84.com"
port: 5510

env:
  AI_ORCHESTRATOR_URL: "http://192.168.1.12:5501"
  SUPABASE_URL: "http://192.168.1.12:8000"
  SUPABASE_SERVICE_KEY: "${SUPABASE_SERVICE_KEY}"
  CLAUDE_API_KEY: "${CLAUDE_API_KEY}"
  CONNECTORS_API_URL: "http://192.168.1.12:5400"
  GITLAB_TOKEN: "${GITLAB_TOKEN}"
  NTFY_URL: "http://192.168.1.12:9090"

volumes:
  - /home/gouroubleu/.ssh:/home/appuser/.ssh:ro
  - /mnt/stock_8to/33800-stack/projects:/mnt/projects:ro

health: "/health"

nginx:
  enabled: true
  ssl: true
  websocket: true

logs:
  enabled: true
  driver: loki

Note : les env vars utilisent des IPs car c'est du container-to-container sur prod-portainer (pas de DNS Pi-hole). Coherent avec la convention existante pour les configs Docker internes.

5. Plan de Construction (mis a jour)

Le CLI arrive des le Sprint 1 — c'est l'interface principale, on en a besoin pour tester.

Sprint 0 — Validation modeles (2-3 jours)

Inchange : pull modeles, tester tool calling, decision Ollama vs vLLM.

Sprint 1 — Fondations + CLI minimal (1 semaine)

[ ] Creer repo GitLab gouroubleu/ulias-org (workspace Bun)
[ ] Tables Supabase (schema agents)
[ ] Agent Runner generique (boucle ReAct)
[ ] Client ai-orchestrator (POST /api/jobs + poll)
[ ] Context Builder basique (layers 1-2 : regles + etat)
[ ] CLI v0 : connexion WS, chat basique, spinners, commande /status
[ ] Direction Generale basique (1 agent a la fois)
[ ] Dockerfile + conf.prod.gouroubleu.yml + CI/CD
[ ] Test : lancer ulias, envoyer un message, voir un agent repondre

Sprint 2 — Equipe Ingenierie + CLI enrichi (1 semaine)

[ ] Agents Coder, Reviewer, Tester, Deployer, Architect
[ ] Pipeline verification en chaine
[ ] CLI : decisions inline (Y/N), diff viewer, /objectives
[ ] Test E2E : "ajouter un endpoint" → code → test → deploy via CLI

Sprint 3 — Equipe Ops + Web UI v0 (1 semaine)

[ ] Agents Monitor, Incident, Backup, Infra
[ ] Taches proactives (cron)
[ ] Web UI v0 : dashboard + page chat (xterm.js)
[ ] Commande /watch dans le CLI

Sprint 4 — Communication + Web UI complete (1 semaine)

[ ] Integration notif-logger (ntfy/mail)
[ ] Resume quotidien auto (mail 8h)
[ ] Web UI : objectifs, decisions, equipes, metriques
[ ] CLI : toutes les commandes slash

Sprint 5-8 — Inchange

(Equipes Recherche/Media/Securite, Transversal, CEO Intel, Fiabilite)

6. Resume des changements

Aspect	v3	v4
Relation ai-orchestrator	Implicite	Projet separe, appel REST
Interface CEO	Web UI seule	CLI live (principal) + Web UI
Structure repo	Plat	Monorepo (packages/cli, packages/server, apps/web-ui)
Port	Non defini	5510
CLI dispo	Sprint 4	Sprint 1
Web UI dispo	Sprint 4	Sprint 3 (v0), Sprint 4 (complete)

Le reste (equipes, agents, Context Builder, apprentissage, schema DB, pipelines) est identique a la v3.