🦾 AgentiLoop Agent!

🌐 Site officiel : agentiloop.ai — téléchargements, documentation, avis et actualités.

⭐ Si Agent! vous fait gagner du temps, mettez une étoile au dépôt. Les étoiles aident d'autres utilisateurs Mac à trouver un agent IA gratuit, natif et open source, et font vivre le projet.

🆕 Le petit nouveau : AgentiLoop CLI ⚡️

La boucle agentique, déchaînée dans votre terminal. Mac. Windows. Linux. À vous de choisir.

Découvrez les nouveaux membres de la famille Agent! : deux CLI multiplateformes aux capacités strictement identiques. Choisissez votre saveur :

Créé avec AgentiLoop Agent! pour Mac. Oui, l'agent a écrit ses propres petits frères. 🤖✨ La v0.0.5 est là : une boîte à outils plus riche (recherche glob/grep, web_fetch, todos, AGENTS.md, /undo, commandes slash personnalisées et --json). Téléchargez-la dès aujourd'hui !

Traductions du README

English · Español · Français · Deutsch · 中文 (简体) · Русский · 한국어 · 日本語

Les échecs dans Agent

Qu'est-ce qu'Agent! ?

Une app. N'importe quelle IA. Le contrôle total de votre Mac.

Agent! est une app 100 % native Swift 6.2 / SwiftUI qui relie 23 fournisseurs de LLM — Claude, Codex, OpenAI, Gemini, Grok, Mistral, Mistral Vibe, DeepSeek, Hugging Face, Z.ai, BigModel, Alibaba DashScope, Qwen, Qwen Code, Meta Muse, MiniMax, OpenRouter, Requesty, A2Agent, OrcaRouter, Ollama (cloud et local), vLLM et LM Studio — plus Apple Intelligence sur l'appareil — à une boucle de tâches autonome qui agit vraiment : elle lit votre code, corrige le bug, compile le projet Xcode, committe le diff, pilote n'importe quelle app Mac via l'API d'Accessibilité, exécute des commandes shell en votre nom ou en root, vous envoie les résultats par iMessage et répond à un « Agent! » prononcé à voix haute.

Pas de NPM, pas d'Electron, pas d'abonnement, pas de télémétrie. Apportez votre propre clé API, tournez entièrement en local, ou gratuitement avec Apple Intelligence. Chaque package Swift dont l'app dépend a été écrit par le même auteur. Voir l'Histoire ci-dessous.

Démarrage rapide (Téléchargement)

1. Téléchargez Agent! et glissez-le dans Applications — ou avec Homebrew :

   brew update && brew install --cask agentiloop-agent
   

2. Ouvrez Agent! — tout se configure automatiquement
3. Choisissez votre IA — Réglages → choisissez un fournisseur → saisissez la clé API

✅ Vous n'avez jamais besoin de compiler depuis les sources. Chaque release et chaque pré-release inclut un binaire Mac précompilé (.dmg + .zip), construit par la CI et signé, notarisé et agrafé (stapled) par Apple avec le Team ID AgentiLoop. Comme les binaires officiels portent un vrai Developer ID, le Launch Agent et le Launch Daemon s'enregistrent toujours et ne sont jamais « perdus » — cela n'arrive qu'avec les builds depuis les sources signés ad hoc (voir Option B ci-dessous). Si vos helpers ont disparu, installez simplement le binaire de la dernière release.

Démarrage rapide (Compiler depuis les sources)

Nécessaire uniquement si vous voulez modifier Agent! lui-même. Pour tous les autres : utilisez le binaire signé ci-dessus.

git clone https://github.com/AgentiLoop/agent.git
cd Agent

Option A — Xcode (compte Apple Developer) : ouvrez Agent.xcodeproj, définissez votre Development Team, compilez et lancez la cible Agent, approuvez le helper quand on vous le demande.

Option B — sans compte développeur (Xcode Command Line Tools uniquement) :

./build.sh              # Debug
./build.sh Release      # Release
open "build/DerivedData/Build/Products/Debug/Agent!.app"

⚠️ Les builds de l'Option B sont signés ad hoc. Les helpers Launch Agent/Daemon ne s'enregistreront pas (SMAppService exige un Team ID), mais la boucle LLM, tous les outils, l'Accessibilité, AppleScript, le shell et MCP fonctionnent quand même.

💡 Configuration économique : GLM-5.3 via Z.ai (inscription la plus rapide, modèle par défaut) coûte quelques centimes par million de tokens. En local ? Seul GLM-4.7-Turbo (32B) tient sur du matériel grand public (Apple Silicon 64–128 Go via Ollama).

Dépannage (Compiler depuis les sources)

• xcode-select pointe vers les Command Line Tools → sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
• BUILD FAILED étrange après un pull → DerivedData obsolète : ./build.sh clean && ./build.sh
• Les helpers ne s'enregistrent jamais → attendu en Option B ; utilisez l'Option A pour les helpers
• Erreurs de deployment target / SDK → Agent! cible macOS 14.6 ; mettez à jour macOS et Xcode
• L'argument de configuration est sensible à la casse → ./build.sh (Debug) ou ./build.sh Release

Que peut-il faire ?

« Compile le projet Xcode et corrige les erreurs » · « Lance ma playlist Workout dans Musique » · « Prends une photo avec Photo Booth » · « Envoie un iMessage à maman pour dire que je rentre à 18 h » · « Ouvre Safari et cherche des vols pour Tokyo » · « Refactorise cette classe en fichiers plus petits » · « Quels événements ai-je aujourd'hui dans le calendrier ? »

Tapez simplement ce que vous voulez. Agent! trouve comment et le réalise.

---

Fonctionnalités clés

• 🧠 Boucle de tâches auto-vérifiée — raisonne, exécute, observe les résultats, se corrige. Une tâche ne peut pas se déclarer terminée tant que les critères de goal_state ne sont pas validés avec des preuves ; un critique optionnel relit d'abord le diff.

• 🛠 Codage agentique — lit les bases de code, modifie via des diffs de remplacement de chaînes, compile les projets Xcode nativement (erreurs cliquables), gère git, indexe les dépôts en une carte JSONL portable. Chaque modification est sauvegardée — rollback en un clic ou rewind_task de toute la tâche.

• 🖥 Automatisation du bureau — pilote n'importe quelle app Mac via l'API d'Accessibilité (AXorcist), basée sur les éléments avec nouvelle tentative floue automatique. Plus NSAppleScript, JXA et 51 ponts ScriptingBridge, le tout en processus avec TCC.

• 📜 AgentScript — dylibs Swift compilées à l'exécution et chargées via dlopen en processus avec TCC complet. Les scripts supprimés vont dans .Trash et sont restaurables.

• 🛡 Exécution privilégiée — shell en votre nom via un Launch Agent, ou en root via un Launch Daemon que vous approuvez une seule fois (SMAppService + XPC). Voir docs/SECURITY.md pour comprendre pourquoi SMAppService impose déjà l'identité de signature.

• 🎙 Voix — dites « Agent! » suivi de votre tâche ; SFSpeechRecognizer sur l'appareil, lancement automatique après ~2,5 s de silence, en boucle.

• 📱 Télécommande iMessage — envoyez Agent! next song depuis votre iPhone ; expéditeurs approuvés uniquement. Nécessite l'Accès complet au disque pour chat.db.

• 🌐 Web — automatisation Safari intégrée (JavaScript + AppleScript) ; Selenium et Playwright MCP optionnels pour le multi-navigateur.

• 🤝 Sous-agents — jusqu'à 3 simultanés (6 en lecture seule) agents isolés avec messagerie par boîte aux lettres et modèle propre par agent.

• 🧩 MCP — ajoutez n'importe quel serveur MCP dans Réglages → Serveurs MCP ; les outils apparaissent comme mcp_<server>_<tool>. Exemples (stdio et HTTP) :

  {
    "mcpServers": {
      "xcode": {
        "transport": "stdio",
        "command": "xcrun",
        "args": ["mcpbridge"],
        "env": {}
      },
      "HelloWorld": {
        "transport": "stdio",
        "command": "/Users/you/bin/mcp-server-hello",
        "args": [],
        "env": {}
      },
      "DemoHttp": {
        "transport": "http",
        "url": "http://localhost:8085/mcp",
        "headers": {}
      }
    }
  }
  

  HelloWorld et DemoHttp sont les serveurs de démonstration d'AgentMCP ; lancez d'abord mcp-server-demo-http pour que DemoHttp ait quelque chose à l'écoute sur le port 8085.

• 🗂 Onglets, historique, mémoire, plans, skills — chaque onglet a son propre dossier de projet et son journal ; mémoire utilisateur persistante ; checklists multi-plans dans chaque prompt.

• 🔄 Chaîne de repli — bascule automatique vers le fournisseur suivant configuré en cas de 429/timeout/panne réseau.

Sponsors

Parrainage

Entreprises et fournisseurs de LLM souhaitant soutenir le projet : consultez docs/SPONSORSHIP.md (niveaux, emplacements) et docs/PROVIDER_PROGRAM.md (intégration des fournisseurs de LLM), ou parrainez directement via GitHub Sponsors. Toute la facturation passe par GitHub Sponsors.

🤖 23 fournisseurs de LLM

Fournisseur	Sponsor	Coût	Idéal pour
A2Agent		Bon marché	DeepSeek, GLM, Kimi, MiniMax et Qwen avec une seule clé compatible OpenAI à une fraction du prix officiel
Apple Intelligence		Gratuit, sur l'appareil	Triage, résumés, compression de tokens (icône cerveau, non disponible dans le sélecteur de fournisseur)
Claude		Au token (clé API) ou abonnement (OAuth)	Longues tâches autonomes, réflexion étendue, cache de prompts
Codex		Abonnement ChatGPT	Modèles OpenAI via OAuth ChatGPT — pas de clé API, pas de facturation au token
DeepSeek		Bon marché	Codage économique, rapport de hits de cache
Google Gemini		Payant (offre gratuite)	Contexte long, vision
Grok (xAI)		Payant	Infos en temps réel
Hugging Face		Variable	Modèles ouverts, serverless ou endpoints dédiés
Meta Muse		Payant	Muse Spark via la Meta Model API (api.meta.ai), clé LLM_… compatible OpenAI
MiniMax		Bon marché	Contexte de 1M tokens
Mistral / Mistral Vibe		Payant	Cloud open-weight, code, produit agent
Ollama (cloud)		Offre gratuite	Modèles ouverts hébergés
Ollama local / vLLM / LM Studio		Gratuit + matériel	Entièrement hors ligne ; vraie fenêtre de contexte par modèle détectée
OpenAI		Payant	Usage général, appels d'outils, vision, reasoning_effort
OpenRouter		Payant	200+ modèles, une clé ; Claude routé via le protocole Anthropic
OrcaRouter		Payant	190+ modèles avec une seule clé compatible OpenAI au prix du fournisseur ; routage auto/fusion/fallback
Alibaba DashScope		Bon marché	Qwen 3.8 via DashScope
Qwen (qwen.ai Token Plan)		Abonnement	QwenCloud Token Plan (clé sk-sp-) : qwen3.8-max, qwen3.7-plus, GLM-5.2, DeepSeek V4
Qwen Code		Abonnement	Alibaba Coding Plan (clé sk-sp-) : qwen3-coder-plus, qwen3.7-plus, GLM-5, Kimi K2.5, MiniMax-M2.5
Requesty		Payant	300+ modèles avec une seule clé compatible OpenAI ; tarifs et capacités par modèle
Z.ai / BigModel		Bon marché	GLM-5.3 — point de départ recommandé

💡 Les fournisseurs auto-hébergés ne sont gratuits qu'au sens des frais d'API — un modèle 30B+ utilisable exige un Mac Studio M2/M3/M4 Ultra (64–128 Go). Sans ce matériel, les voies cloud bon marché ci-dessus reviennent bien moins cher.

Outils

Les noms canoniques viennent de AgentTools.Name.* (source : le package AgentTools). Les interrupteurs par fournisseur permettent de masquer des outils individuels.

Groupe	Outils
Core	done · list_tools · search · web_search · fetch · chat · memory · plan · goal_state · restore_tool_result · directory · skill · ask_user · index
Code / build	file (read/write/edit/diff_apply/undo/list/search/mkdir/…) · git · xcode (build/run/analyze/snippet/code_review/add_file/bump_version/…) · agent_script
Shell	user_shell (Launch Agent) · root_shell (Launch Daemon) · shell (repli en processus) · batch · multi
Automatisation macOS	accessibility (25 actions basées sur les éléments) · applescript (avec lookup_sdef) · javascript (JXA)
Web	safari · selenium · mcp_playwright_browser_* (optionnel)
Sous-agents	spawn_agent · tell_agent

Référence complète par action : docs/TECHNICAL.md.

AgentScript — Scripts Swift avec TCC complet

Les AgentScripts sont de simples fichiers Swift dans ~/Documents/AgentScript/agents/Sources/Scripts/. Agent! compile chacun en .dylib avec SwiftPM (Package.swift liste chaque script plus les 51 ponts ScriptingBridge), puis le charge via dlopen avec les autorisations TCC d'Agent! lui-même — Accessibilité, Automatisation, Calendrier, Contacts, Mail, Photos, etc. Le LLM les gère avec agent_script (create / edit / run / delete / restore / pull) ; ~35 exemples sont fournis dans le dossier (Hello, TodayEvents, NowPlaying, CheckMail, CreateDmg, ArchiveXcode, …).

Point d'entrée — pas de code de niveau supérieur, pas de exit() ; stdout est renvoyé au LLM, la valeur de retour est le code de sortie :

import Foundation
import CalendarBridge   // tout `import XBridge` est câblé automatiquement — aucune modification de Package.swift

@_cdecl("script_main")
public func scriptMain() -> Int32 {
    print("Hello from AgentScript! 👋")
    return 0
}

Variables d'environnement — comment elles sont DÉFINIES. Le LLM ne touche jamais lui-même à l'environnement. Il appelle l'outil, et le ScriptService d'Agent! exporte les variables dans le processus du script (env["AGENT_PROJECT_FOLDER"] = cwd, env["AGENT_SCRIPT_ARGS"] = arguments dans ScriptService+Execution.swift ; setenv(...) pour la variante en processus). Les deux mêmes variables sont exportées vers chaque commande user_shell / root_shell / shell.

Appel d'outil du LLM                                   Ce qu'Agent! exporte vers le script
─────────────────────────────────────────────────────  ─────────────────────────────────────────────
agent_script(action:"run", name:"TodayEvents")         AGENT_PROJECT_FOLDER=/Users/vous/Documents/GitHub/Agent
                                                       (AGENT_SCRIPT_ARGS n'est PAS définie)

agent_script(action:"run", name:"TodayEvents",         AGENT_PROJECT_FOLDER=/Users/vous/Documents/GitHub/Agent
             arguments:"days=3,location=false,json=true")   AGENT_SCRIPT_ARGS="days=3,location=false,json=true"

Variable	Quand définie	Signification
AGENT_PROJECT_FOLDER	Toujours	Le dossier de projet de l'onglet actif (ou $HOME s'il n'y en a pas). Le cwd du runner y est aussi positionné.
AGENT_SCRIPT_ARGS	Seulement quand le LLM passe arguments:"…"	La chaîne passée par le LLM, telle quelle. Les exemples utilisent la convention key=value,key=value.

Variables d'environnement — comment elles sont LUES. Dans le script, les deux proviennent de ProcessInfo.processInfo.environment. C'est exactement le schéma d'analyse de Hello.swift / TodayEvents.swift :

import Foundation

@_cdecl("script_main")
public func scriptMain() -> Int32 {
    let env = ProcessInfo.processInfo.environment

    // 1. Dossier de projet — toujours présent ; repli sur le cwd par précaution
    let folder = env["AGENT_PROJECT_FOLDER"] ?? FileManager.default.currentDirectoryPath

    // 2. Arguments — absents sauf si le LLM a passé `arguments:"…"`
    let argsString = env["AGENT_SCRIPT_ARGS"] ?? ""

    // 3. Valeurs par défaut, puis analyse de "key=value,key=value"
    var daysAhead    = 0
    var showLocation = true
    var outputJSON   = false

    for pair in argsString.split(separator: ",") {
        let parts = pair.split(separator: "=", maxSplits: 1).map { $0.trimmingCharacters(in: .whitespaces) }
        guard parts.count == 2 else { continue }
        switch parts[0] {
        case "days":     daysAhead    = Int(parts[1]) ?? 0
        case "location": showLocation = parts[1].lowercased() == "true"
        case "json":     outputJSON   = parts[1].lowercased() == "true"
        default: break
        }
    }

    print("Dossier de projet : \(folder)")
    print("days=\(daysAhead) location=\(showLocation) json=\(outputJSON)")
    return 0
}

Les deux variables sont indépendantes — ne jamais extraire le dossier de projet de AGENT_SCRIPT_ARGS. Équivalent Bash dans user_shell : ls "$AGENT_PROJECT_FOLDER/Sources" (le cwd y est déjà, pas besoin de cd).

Conventions réelles de AGENT_SCRIPT_ARGS dans les scripts fournis (~/Documents/AgentScript/agents/Sources/Scripts/) :

Script	arguments: passé par le LLM	Style
TodayEvents	days=3,location=false,json=true	key=value,…
CheckMail	unreadOnly=true,inboxCount=true,json=true	key=value,…
ListReminders	completed=false,limit=5	key=value,…
QuitApps	excluded=Xcode,Agent,Terminal	key=value avec une liste
NowPlaying	json=true,artwork=true	key=value,…
ArchiveXcode	/path/to/Project.xcodeproj MyScheme 469UCUB275	positionnel, séparé par des espaces (scheme/teamID détectés automatiquement s'ils sont omis)
CreateDmg	--app /path/to/App.app --output /path/out.dmg --name "My App" --compress	style drapeaux, séparé par des espaces, guillemets respectés

Entrée / sortie JSON — un mécanisme SÉPARÉ des variables d'environnement. Les variables d'environnement sont exportées par Agent! dans le processus ; les fichiers JSON sont de simples fichiers sur disque que le script lui-même lit et écrit avec FileManager / JSONSerialization. Agent! ne les crée pas, ne les transmet pas et ne les analyse pas. Deux schémas réels tirés des scripts fournis :

1. Entrée JSON uniquement (SendMessage) — aucun argument d'environnement ; le script exige SendMessage_input.json et renvoie 1 s'il est absent :

// ~/Documents/AgentScript/json/SendMessage_input.json   (écrit par le LLM via file(action:"write") avant l'exécution)
{ "recipient": "Maman", "message": "À la maison à 18 h", "imagePath": "~/Pictures/Photos Library.photoslibrary/originals/A/IMG_0001.jpeg" }

// ~/Documents/AgentScript/json/SendMessage_output.json  (écrit par le script)
{ "success": true, "timestamp": "2026-09-03T21:14:02Z", "recipient": "Maman", "message": "À la maison à 18 h" }
// en cas d'échec : { "success": false, "timestamp": "…", "error": "Missing required field: recipient" }

// SendMessage.swift — comment le script le lit
let inputPath  = "\(NSHomeDirectory())/Documents/AgentScript/json/SendMessage_input.json"
guard let inputData = FileManager.default.contents(atPath: inputPath) else {
    writeOutput(outputPath, success: false, error: "Input file not found: \(inputPath)"); return 1
}
guard let json = try? JSONSerialization.jsonObject(with: inputData) as? [String: Any],
      let recipientHandle = json["recipient"] as? String else { /* … */ return 1 }
let message   = json["message"]   as? String
let imagePath = json["imagePath"] as? String

2. Arguments d'environnement pour les options, JSON pour la sortie structurée (TodayEvents, NowPlaying, CheckMail, ListReminders) — les options viennent de AGENT_SCRIPT_ARGS (ou du fichier optionnel <Name>_input.json) ; avec json=true le script écrit <Name>_output.json en plus de la sortie lisible sur stdout qui revient au LLM :

// agent_script(action:"run", name:"TodayEvents", arguments:"days=3,json=true")
// → ~/Documents/AgentScript/json/TodayEvents_output.json
{ "success": true, "timestamp": "…", "count": 2,
  "events": [ { "summary": "Standup", "calendar": "Work", "startTime": "…", "endTime": "…", "allDay": false, "location": "…" }, … ] }

// agent_script(action:"run", name:"NowPlaying", arguments:"json=true,artwork=true")
// → ~/Documents/AgentScript/json/NowPlaying_output.json
{ "success": true, "playerState": "playing",
  "track": { "name": "…", "artist": "…", "album": "…", "duration": 240 },
  "artwork": { "saved": true, "path": "~/Documents/AgentScript/images/….png", "width": 500, "height": 500 } }

// TodayEvents.swift — comment le script l'écrit
func writeTodayEventsOutput(_ path: String, success: Bool, error: String? = nil,
                            events: [[String: Any]]? = nil, count: Int? = nil, outputJSON: Bool) {
    guard outputJSON else { return }
    var result: [String: Any] = ["success": success, "timestamp": ISO8601DateFormatter().string(from: Date())]
    if !success, let error { result["error"] = error }
    if success { if let events { result["events"] = events }; if let count { result["count"] = count } }
    try? FileManager.default.createDirectory(atPath: (path as NSString).deletingLastPathComponent, withIntermediateDirectories: true)
    if let out = try? JSONSerialization.data(withJSONObject: result, options: .prettyPrinted) {
        try? out.write(to: URL(fileURLWithPath: path))
    }
}

Les scripts supprimés vont dans ~/Documents/AgentScript/agents/.Trash/ (agent_script(action:"restore")) ; action:"pull" récupère la version upstream depuis le dépôt AgentScripts.

🔒 Jev — un second avis avant les commandes shell

Jev (TypeSafe System One) est une couche de décision optionnelle qui examine les commandes shell avant qu'Agent! ne les exécute. Elle complète le fournisseur de LLM que vous avez choisi — elle ne le remplace jamais.

• Ce qu'elle fait. Chaque commande ayant déjà passé les règles figées de ShellSafetyService est envoyée à Jev, qui évalue la probabilité qu'elle détruise des données de façon irréversible. Au-dessus de votre seuil, la commande est refusée avec le pourcentage et le texte de la commande ; en dessous, elle s'exécute.
• Où cela s'applique. Sur tous les chemins shell : le shell in-process, le Launch Agent utilisateur (user_shell) et le Launch Daemon privilégié (root_shell).
• Seuil réglable. Réglages → LLM Common Settings → Reject at … % destructive, de 0 à 100 % par paliers de 10 %. Valeur par défaut : 70 %.
• Conçu pour échouer en mode ouvert. Sans clé API, avec l'interrupteur Consult Jev before tools désactivé, ou en cas de panne de TypeSafe, le résultat est « aucun avis » : la commande continue et l'échec est journalisé, jamais présenté silencieusement comme un verdict sûr. Annuler une tâche pendant une vérification Jev empêche la commande de démarrer.
• Visible. Chaque vérification journalise le pourcentage de risque destructif, le verdict autorisé/refusé, le modèle ayant répondu et le nombre de tokens en entrée/sortie.
• Configuration. La clé API (stockée dans le Trousseau), le sélecteur de modèle avec rafraîchissement du catalogue et l'interrupteur d'avis se trouvent dans LLM Common Settings. Le client réside dans le paquet Swift embarqué TypeSafeKit / TypeSafeMiddleware.

Confidentialité et sécurité

Vos fichiers, le contenu de votre écran et vos données personnelles ne quittent jamais votre Mac — les fournisseurs cloud ne voient que le texte du prompt ; les fournisseurs locaux gardent tout hors ligne. Chaque action est journalisée.

Couche	Ce qu'elle fait
Shell Safety Service	Bloque en dur rm -rf /, rm -rf ~, rm -rf avec glob nu, --no-preserve-root — appliqué côté client et côté daemon. Impossible à contourner par le LLM.
Confiance des clients XPC	Les deux listeners exigent une signature de code de la même équipe, dérivée de la propre signature de l'app ; les builds release rejettent les clients sans équipe.
Garde read-before-edit	Les modifications de fichiers non lus ou modifiés en externe sont refusées (SHA-256), avec lecture automatique au refus.
Sauvegardes de fichiers + rewind	Chaque modification est sauvegardée (TTL d'une semaine) ; UI de Rollback, file(action:"undo") ou rewind_task par tâche.
Routage TCC en processus	Les commandes AppleScript/JXA/screencapture/accessibilité s'exécutent en processus, là où Agent! détient les autorisations TCC, jamais via les daemons.
Contrôle d'exécution des outils	Le LLM ne peut pas inventer de résultats — chaque appel passe par dispatchTool() et renvoie une sortie réelle. Les affirmations « j'ai cliqué/cherché… » sans outil reçoivent une correction injectée.
Erreurs typées + gardes	Chaque résultat d'outil en échec porte un indice de récupération ; les gardes « disque rayé » et « bloqué » relancent puis s'arrêtent ; les portes de fin limitent les refus à 3 par tâche.
Piste d'audit Console	Chaque appel d'outil et chaque commande du helper sont journalisés.

Raccourcis clavier et commandes slash

Raccourci	Action
Return	Lancer la tâche · ⌘ . / Esc annuler
⌘ T / ⌘ W / ⌘ 1–9 / ⌘ ⇧ ←→	Nouvel / fermer / changer / précédent-suivant onglet
⌘ B / ⌘ D	Basculer la superposition de sortie LLM / les chevrons
⌘ F / ⌘ L / ⌘ V	Rechercher dans le journal / vider le journal / coller une image
↑ / ↓	Historique des prompts
⌘ ⇧ M / ⌘ ⇧ P	Moniteur Messages / Réglages
⌘ ⇧ K L H J U	Tout effacer / panneau LLM / historique des prompts / historique des tâches / compteurs de tokens

Les commandes slash s'exécutent en local : /clear [log|all|llm|history|tasks|tokens], /memory [show|clear|edit|<texte>], /auto ….

Pilote automatique (/auto)

Exécute la boucle de tâches en cycles sans surveillance (dans l'onglet principal ou n'importe quel onglet LLM) jusqu'à ce qu'un objectif soit atteint, qu'un budget de temps soit épuisé ou que vous appuyiez sur Arrêter. Il n'y a ni limite de cycles ni plafond d'itérations par cycle : quand la tâche d'un cycle est entièrement terminée et que l'objectif n'est pas atteint, le cycle suivant démarre automatiquement.

Commande	Ce qu'elle fait
/auto <goal>	Travaille vers l'objectif jusqu'à ce que le LLM le signale atteint
/auto 4h <goal>	Pareil, mais s'arrête après 4 heures (30m et 1.5h fonctionnent aussi)
/auto	Examine d'abord le projet, puis vous demande l'objectif via ask_user
/auto history	Liste les objectifs précédents du pilote automatique
/auto last / /auto #N	Relance l'objectif le plus récent / le N-ième de l'historique
/auto add <folder>	Ajoute un dossier de parité : chaque modification du projet y est répliquée
/auto remove <folder>	Retire un dossier de parité
/auto status / /auto stop	Affiche la session / la termine après le cycle en cours (immédiatement entre deux cycles)

Chaque cycle est une tâche normale ; son résumé est ajouté à .agent/autopilot/progress.md et injecté dans le prompt du cycle suivant. Le LLM termine la session en commençant son résumé final par AUTOPILOT: GOAL REACHED. Les cycles qui se terminent sans résumé (erreurs, annulations) ne terminent jamais la session : le cycle suivant attend simplement plus longtemps (15 s, 30 s, 60 s… jusqu'à 5 min). Les commandes /auto sont enregistrées dans l'historique des prompts (flèche haut) et les objectifs dans la liste /auto history. Les sessions actives survivent aux redémarrages de l'app : quitter (ou un plantage) les met en pause, et au lancement suivant chacune reprend dans son onglet avec le cycle suivant.

FAQ

Dois-je savoir coder ? Non — du français courant (ou votre langue maternelle). Combien ça coûte ? L'app est gratuite pour un usage non commercial et personnel (PolyForm Noncommercial 1.0.0). Vous payez votre fournisseur ; GLM-5.3 via Z.ai/BigModel ou DeepSeek sont les moins chers pour un travail sérieux. Les modèles locaux sont gratuits si vous possédez le matériel. Quel Mac me faut-il ? Apple Silicon ou Intel, macOS 14.6+. N'importe quel Mac récent pour les fournisseurs cloud ; 64 Go+ pour les modèles locaux 30B. Quelle différence avec Siri ? Siri répond. Agent! agit — apps, fichiers, code, système.

Plus : docs/FAQ.md · Architecture technique · Comparaisons (vs Claude Code, Cursor, Cline, OpenClaw) · Modèle de sécurité

Histoire

Agent! est le fruit de trois années de développement d'apps d'IA agentique — ANIE, Game Changer, BattleScript, XCF MCP Server and Client, D1F et environ huit packages Swift originaux. La pièce manquante était une boucle autonome intelligente ; une fois obtenue, le meilleur de ces projets s'est réuni dans Agent!. Il a écrit des jeux vidéo (Boss-Man), créé des apps, écrit de la poésie dans Pages via AppleScript, généré des images disque et les a jointes à des releases GitHub. Là où Claude Code repose sur ~65 packages NPM tiers, Agent! est 100 % natif, consomme très peu de RAM et embarque d'origine l'automatisation Xcode, l'analyse Swift Syntax 6.2, l'Accessibilité, AppleScript, AgentScript/ScriptingBridge, l'automatisation Safari et le support MCP.

Rétro-ingénierie avec Agent!

Agent! est aussi un atelier de rétro-ingénierie. Il lit les images disque et les ROM, écrit les outils d'extraction, étudie le code décompilé et reconstruit le jeu dans le navigateur en vérifiant son travail par rapport aux données d'origine. Quatre jeux de course et un jeu de combat ont été créés ainsi :

Jeu	Ce qu'Agent! a fait	Jouer
🚕 CrazyTaxi	Reconstruction en Three.js de Crazy Taxi (USA) sur Sega Dreamcast. Des outils Python extraient les circuits, véhicules, personnages, animations et l'audio de votre propre disque. Le code des collisions est porté depuis la décompilation et vérifié par rapport aux données extraites	Votre propre disque requis
🍄 MarioKart64JS	Mario Kart 64 reconstruit en Three.js, sans émulation. Circuits, karts, musique et voix proviennent de la ROM N64 d'origine, avec les 16 circuits, les arènes de combat, 15 objets, des textures HD et le jeu en ligne	mk64js.gokart.games
🏎️ F1	Course de monoplaces contre une grille IA sur 18 vrais circuits. Tracés, dénivelés et virages relevés reconstruits à partir de positions réelles des voitures et de la télémétrie de l'API OpenF1	f1.gokart.games
🏁 GoKart	Jeu de karts original sous Godot 4 qui reprend les règles de Mario Kart 64 (aspiration, cylindrées, points du Grand Prix, menus, musique), tout étant généré par le code, avec du multijoueur en ligne	gokart.games
🦇 BvS	Batman v Superman, un jeu de combat 3D en Three.js où chaque pixel est dessiné par le code : aucun fichier de modèle, texture ni échantillon audio	bvs.agentiloop.ai

Aucun de ces dépôts ne contient de ressources des jeux. CrazyTaxi et MarioKart64JS nécessitent votre propre copie du jeu. Tous sont des créations de fans pour un usage personnel et éducatif.

La famille Agent!

Agent! est construit à partir d'un ensemble de dépôts compagnons dans l'organisation AgentiLoop. Actualités, téléchargements et kit presse sur 🌐 agentiloop.ai (code du site).

Dépôt	Ce que c'est
AgentiLoopCLI · AgentiLoopGo	La boucle de l'agent en CLI multiplateformes pour macOS, Windows et Linux (Rust · Go)
AgentScripts	Les scripts Swift qu'Agent! compile et exécute en processus
AgentTools	Schémas d'outils, prompts système et gestion des fournisseurs
AgentLLM	Protocoles, types et registre des fournisseurs LLM
AgentMCP	Client MCP (stdio + HTTP)
AgentAccess	Automatisation de l'accessibilité
AgentEventBridges	Protocoles ScriptingBridge pour plus de 50 apps Mac
AgentD1F	Moteur de diff multiligne
AgentSwift	Analyse de code SwiftSyntax
AgentColorSyntax · AgentTerminalNeo	Coloration syntaxique · markdown façon terminal rétro
AgentAudit	Journalisation d'audit os.log

Star History

Contribuer

Voir CONTRIBUTING.md — compilez depuis les sources en ~5 minutes avec ./build.sh, sans compte développeur. Les pull requests passent par le workflow CI Build & Test. Consultez les good first issues.

Licence

PolyForm Noncommercial 1.0.0 — gratuit pour un usage non commercial et personnel. L'usage commercial et les versions commerciales du logiciel sont réservés exclusivement à AgentiLoop.ai, une société de Logos InkPen LLC. Contactez AgentiLoop pour une licence commerciale.

---

⚠️ Avis Légal et Attribution

Avis de Marque Déposée

« AgentiLoop Agent! for Mac » est un projet logiciel indépendant et n'est pas affilié à, approuvé par, sponsorisé par, ni autrement associé à Apple Inc. « Apple », « Mac », « Mac mini », « MacBook », « macOS », et les marques associées sont des marques déposées d'Apple Inc., enregistrées aux États-Unis et dans d'autres pays. Toutes les autres marques déposées, marques de service et noms commerciaux mentionnés ici sont la propriété de leurs détenteurs respectifs et sont utilisés à des fins d'identification uniquement.

« AgentiLoop Agent! » et le logo AgentiLoop Agent! sont des marques déposées de AgentiLoop.ai, une société de Logos InkPen LLC. L'utilisation de ces marques nécessite une autorisation écrite préalable. La licence PolyForm Noncommercial ci-dessous accorde des droits uniquement sur le code source — elle n'accorde aucun droit de marque.

Licence du Code Source (PolyForm Noncommercial 1.0.0)

Le code source de « AgentiLoop Agent! for Mac » est disponible et sous licence PolyForm Noncommercial License 1.0.0. Vous êtes libre d'utiliser, copier, modifier et distribuer le code source à toute fin non commerciale, sous réserve des conditions du fichier LICENSE (conserver le Required Notice ainsi qu'une copie des termes de la licence ou un lien vers ceux-ci). L'usage commercial et les versions commerciales du logiciel sont réservés exclusivement à AgentiLoop.ai, une société de Logos InkPen LLC.

Binaires Compilés et Releases

Les binaires compilés, installateurs, builds signés, et artefacts de release distribués via les GitHub Releases de ce projet, AgentiLoop.ai, ou tout autre canal officiel, sont l'œuvre protégée par le droit d'auteur de AgentiLoop.ai, une société de Logos InkPen LLC et ne sont pas couverts par la licence PolyForm Noncommercial qui régit le code source. Tous les droits sur les binaires officiels — y compris le nom « AgentiLoop Agent! », le logo, l'identité de signature de code, et le Developer ID — sont réservés.

Copyright © 2026 AgentiLoop.ai, une société de Logos InkPen LLC. Tous droits réservés.

Vous êtes libre de compiler vos propres binaires à partir des sources pour un usage non commercial sous la licence PolyForm Noncommercial, à condition de ne pas utiliser le nom « AgentiLoop Agent! », le logo, ou la marque pour identifier votre produit.

Clause de Non-Garantie

Ce logiciel est fourni « TEL QUEL », sans garantie d'aucune sorte, expresse ou implicite, y compris mais sans s'y limiter les garanties de qualité marchande, d'adéquation à un usage particulier, et de non-contrefaçon. En aucun cas l'auteur ou le détenteur des droits d'auteur ne pourra être tenu responsable de toute réclamation, dommage ou autre responsabilité, que ce soit dans le cadre d'une action contractuelle, délictuelle, ou autre, découlant de, résultant de, ou en lien avec le logiciel ou l'utilisation ou d'autres transactions du logiciel.

---

Merci de votre intérêt pour AgentiLoop Agent! — une application conçue pour les ordinateurs Mac mini, MacBook, et Mac Studio fonctionnant sous macOS 14.6 ou ultérieur sur du matériel et logiciel Mac authentique.

• Website: https://AgentiLoop.ai
• Github : https://github.com/AgentiLoop/agent

---