Déployez des agents de codage IA auto-hébergés (OpenClaw, Claude Code, Codex) dans votre compte AWS avec CloudFormation, des profils IAM et un isolement en sandbox pour le développement full-stack automatisé et la gestion d'infrastructure.
# Agents de codage IA auto-hébergés sur AWS — OpenClaw, Claude Code, Codex, Kiro, NemoClaw, Hermes
[](https://www.youtube.com/watch?v=dJSk8DYlHvI)
▶️ [Regarder la démonstration complète sur YouTube](https://www.youtube.com/watch?v=dJSk8DYlHvI)
📝 [Lire l'article de blog : "J'ai donné à mon agent son propre compte AWS"](https://robotpaper.ai/i-gave-my-agent-its-own-aws-account-and-now-it-codes-deploys-and-debugs-full-stack-apps/)
> **En résumé — déployer Lowkey :**
>
> ```sh
> curl -sfL install.lowkey.run | bash
> ```
>
> Fonctionne dans **bash**, **zsh** et **AWS CloudShell**. L'installateur vous guide à travers le pack, le profil et la méthode de déploiement de manière interactive.
>
> 
>
> **Exemples en une ligne (non interactif) :**
> ```sh
> # Full builder agent (can create/modify/delete AWS resources)
> curl -sfL install.lowkey.run | bash -s -- -y --pack openclaw --profile builder
>
> # Read-only advisor (can see everything, change nothing)
> curl -sfL install.lowkey.run | bash -s -- -y --pack openclaw --profile account_assistant
>
> # Personal assistant (Bedrock only, no AWS access)
> curl -sfL install.lowkey.run | bash -s -- -y --pack claude-code --profile personal_assistant
>
> # Sandboxed personal assistant (NemoClaw — isolated in OpenShell sandbox)
> curl -sfL install.lowkey.run | bash -s -- -y --pack nemoclaw --profile personal_assistant
>
> # Kiro CLI agent (AWS agentic IDE — requires interactive login after deploy)
> curl -sfL install.lowkey.run | bash -s -- -y --pack kiro-cli --profile builder
>
> # Codex CLI agent (OpenAI — builder agent, no Bedrock)
> curl -sfL install.lowkey.run | bash -s -- -y --pack codex-cli
> # After deploy, SSM into the instance and run: codex login
> # (ChatGPT/browser OR API key — your choice)
> ```
>
> Nécessite : AWS CLI + accès administrateur sur un **compte sandbox dédié**.
>
> ⚠️ Déployez dans un compte propre — les LLM font des erreurs, un sandbox limite le rayon d'impact.
>
> **Désinstallation :** `curl -sfL uninstall.lowkey.run | bash`
---
## Pour commencer
### Étape 1 : Installer Lowkey
Exécutez `curl -sfL install.lowkey.run | bash` — l'installateur vous guide à travers le **pack**, le **profil**, la **taille d'instance** et la **méthode de déploiement** (CLI CloudFormation ou Console).
> **📊 Désactivation de la télémétrie :** L'installateur envoie une télémétrie anonyme d'installation (début/succès/échec + OS/arch/durée — aucun code, identifiants, IP ou nom d'hôte). Pour désactiver avant l'installation :
> ```bash
> mkdir -p ~/.lowkey && touch ~/.lowkey/telemetry-off
> ```
> Ou définissez `LOWKEY_TELEMETRY=0` lors de l'exécution de l'installateur. [Détails complets sur la confidentialité →](https://docs.lowkey.run/reference/telemetry-privacy)
**Options CLI pour les déploiements non interactifs :**
| Option | Description |
|------|-------------|
| `--non-interactive` | Ignorer toutes les invites, utiliser les valeurs par défaut (alias : `--yes`, `-y`) |
| `--pack <name>` | Pack d'agent : `openclaw`, `claude-code`, `hermes`, `nemoclaw`, `kiro-cli`, `codex-cli`, `pi`, `ironclaw`, `roundhouse` |
| `--profile <name>` | Profil de permissions : `builder`, `account_assistant`, `personal_assistant` |
| `--method <method>` | Méthode de déploiement : `cfn` (CloudFormation) |
**Profils de permissions :**
| Profil | IAM | Instance | Cas d'utilisation |
|---------|-----|----------|----------|
| 🔴 `builder` | AdministratorAccess | t4g.xlarge | Construire des applications, déployer l'infrastructure, gérer les pipelines |
| 🟡 `account_assistant` | ReadOnlyAccess + Bedrock | t4g.medium | Analyse des coûts, revue d'architecture, débogage |
| 🟢 `personal_assistant` | Bedrock uniquement | t4g.medium | Rédaction, recherche, aide au codage, tâches quotidiennes |
**Packs d'agents :**
| Pack | Description | Instance | Volume de données |
|------|-------------|----------|-------------|
| **OpenClaw** (par défaut) | Agent IA avec état, passerelle 24/7, mémoire persistante, Telegram/Discord/Slack | t4g.xlarge recommandé | 80 Go |
| **Claude Code** | Agent de codage d'Anthropic — support natif Bedrock, version CLI épinglée, plugins AWS + MCP, accès complet aux outils | t4g.large recommandé | Aucun nécessaire (mettre à 0) |
| **Hermes** *(expérimental)* | Agent CLI NousResearch — plus léger, axé terminal, compétences auto-améliorées | t4g.medium suffisant | Aucun nécessaire (mettre à 0) |
| **Pi** *(expérimental)* | Harnais de codage terminal minimal — outils de lecture, écriture, édition, bash | t4g.medium suffisant | Aucun nécessaire (mettre à 0) |
| **IronClaw** *(expérimental)* | Agent IA basé sur Rust par NEAR AI — binaire statique, démarrage rapide | t4g.medium suffisant | Aucun nécessaire (mettre à 0) |
| **NemoClaw** *(expérimental)* | OpenClaw dans le sandbox NVIDIA OpenShell — isolation Landlock + seccomp + netns, Bedrock via bedrockify. Profil `personal_assistant` uniquement. | t4g.xlarge requis | 80 Go |
| **Kiro CLI** *(expérimental)* | Client terminal IDE agentic AWS avec support serveur MCP. Utilise sa propre inférence cloud (pas Bedrock). Nécessite une connexion SSO interactive après déploiement. | t4g.medium suffisant | Aucun nécessaire (mettre à 0) |
| **Codex CLI** *(expérimental)* | Agent de codage Codex d'OpenAI — utilise directement l'API OpenAI (pas Bedrock). Configuré comme agent builder (danger-full-access). **Une fois l'installation terminée**, connectez-vous en SSM à l'instance et exécutez `codex login`. | t4g.medium suffisant | Aucun nécessaire (mettre à 0) |
| **Troika** *(expérimental)* | Machine de codage à trois harnais — OpenClaw/Hermes + Claude Code + Codex CLI, le tout via Amazon Bedrock. Choisissez un pilote quotidien pour un lancement automatique à la connexion SSM ; changez avec `agents driver <name>`. Réservé au builder. Nécessite l'accès aux modèles Anthropic + Bedrock Mantle. | t4g.xlarge requis | 80 Go |
L'installateur découvre les packs dynamiquement et demande lequel déployer. Les packs expérimentaux sont clairement marqués.
> **Fonctionne depuis AWS CloudShell !** Vous pouvez exécuter l'installateur directement depuis [AWS CloudShell](https://console.aws.amazon.com/cloudshell/) — aucune configuration locale nécessaire. CloudShell a déjà des identifiants AWS configurés via votre session console.
<details>
<summary><strong>Déploiement manuel (alternative)</strong></summary>```bash
# Clone
git clone https://github.com/inceptionstack/lowkey.git
cd lowkey/deploy/cloudformation
# Deploy (OpenClaw — default)
aws cloudformation create-stack \
--stack-name my-loki \
--template-body file://template.yaml \
--parameters ParameterKey=EnvironmentName,ParameterValue=my-loki \
--capabilities CAPABILITY_NAMED_IAM \
--region us-east-1
# Deploy (Hermes — lighter alternative)
aws cloudformation create-stack \
--stack-name my-hermes \
--template-body file://template.yaml \
--parameters \
ParameterKey=EnvironmentName,ParameterValue=my-hermes \
ParameterKey=PackName,ParameterValue=hermes \
ParameterKey=InstanceType,ParameterValue=t4g.medium \
ParameterKey=DataVolumeSize,ParameterValue=0 \
--capabilities CAPABILITY_NAMED_IAM \
--region us-east-1
# Wait ~10 min, then connect
aws ssm start-session --target <instance-id>
# Talk to your Lowkey
openclaw tui # or use the alias: loki tui
```
Guide de déploiement complet : [Deploying Lowkey on AWS](https://github.com/inceptionstack/lowkey/wiki/Deploying-Lowkey-on-AWS)
</details>
### Étape 2 : Exécuter les bootstraps essentiels
> **Important — ces bootstraps réduisent les erreurs et améliorent significativement le comportement de l'agent.**
Après vous être connecté à Lowkey pour la première fois, exécutez les bootstraps essentiels. Ils se trouvent à l'adresse : [`bootstraps/essential/`](https://github.com/inceptionstack/lowkey/tree/main/bootstraps/essential)
**Exemple de prompt** — collez ceci dans votre chat Lowkey :
> *"Lowkey, veuillez vous amorcer à partir de cette url https://github.com/inceptionstack/lowkey/tree/main/bootstraps/essential"*
Bootstraps essentiels disponibles :
- **BOOTSTRAP-ALARMS** — Configure la surveillance des alarmes CloudWatch
- **BOOTSTRAP-CODING-GUIDELINES** — Définit les normes de développement et les pratiques de codage
- **BOOTSTRAP-DAILY-UPDATE** — Configure les procédures de mise à jour quotidienne
- **BOOTSTRAP-DIAGRAMS** — Active la génération de diagrammes d'architecture
- **BOOTSTRAP-DISK-SPACE-STRAT** — Met en place une stratégie de gestion de l'espace disque
- **BOOTSTRAP-MCPORTER** — Configure MCPorter pour la gestion des outils MCP
- **BOOTSTRAP-MEMORY-SEARCH** — Active la fonctionnalité de recherche en mémoire persistante
- **BOOTSTRAP-PLAYWRIGHT** — Configure l'automatisation du navigateur Playwright
- **BOOTSTRAP-SECRETS-AWS** — Configure la gestion des secrets et des identifiants AWS
- **BOOTSTRAP-SECURITY** — Établit les protocoles et directives de sécurité
### Étape 3 : Exécuter les bootstraps optionnels
> Utile — jetez un coup d'œil et choisissez ce qui correspond à votre flux de travail.
Après avoir exécuté les bootstraps essentiels, exécutez les bootstraps optionnels de votre choix, situés à l'adresse : [`bootstraps/optional/`](https://github.com/inceptionstack/lowkey/tree/main/bootstraps/optional)
Bootstraps optionnels disponibles :
- **BOOTSTRAP-GITHUBACTION-CODE-REVIEW** — Intègre GitHub Actions avec une revue de code automatisée
- **BOOTSTRAP-PIPELINE-NOTIFICATIONS** — Configure les notifications de pipeline CI/CD
- **BOOTSTRAP-SKILLS** — Installation manuelle / récupération de la bibliothèque loki-skills (auto-installée par le pack openclaw)
- **BOOTSTRAP-WEB-UI** — Configure l'interface utilisateur web
- **OPTIMIZE-TOO-LARGE-CONTEXT** — Stratégies d'optimisation pour les grands contextes
### Étape 4 : Intégration Telegram (si nécessaire)
Si vous souhaitez utiliser Lowkey via Telegram, exécutez les bootstraps Telegram situés à l'adresse : [`bootstraps/telegram/`](https://github.com/inceptionstack/lowkey/tree/main/bootstraps/telegram)
- **BOOTSTRAP-TELEGRAM** — Met en place une intégration de base du bot Telegram
- **BOOTSTRAP-TELEGRAM-GROUP** — Configure les fonctionnalités de chat de groupe Telegram
### Désinstallation
Supprimez un ou tous les déploiements Lowkey de votre compte :```sh
curl -sfL uninstall.lowkey.run | bash
```
Trouve les déploiements par tag, vous permet de choisir lesquels supprimer, supprime les piles CloudFormation (les déploiements Terraform hérités sont toujours démantelés via une référence héritée épinglée), et supprime optionnellement les buckets d'état/les tables de verrouillage.
---
## Système de Packs
Lowkey utilise une **architecture basée sur les packs** pour déployer différents runtimes d'agents IA. Chaque pack est un module autonome avec son propre script d'installation, son manifeste et ses ressources.
### Packs Disponibles
| Pack | Type | Description |
|------|------|-------------|
| `bedrockify` | Base (auto-installé) | Proxy compatible OpenAI pour Amazon Bedrock. Fonctionne comme un démon systemd sur le port 8090. La plupart des packs d'agents en dépendent. |
| `openclaw` | Agent | Agent IA complet avec état, passerelle 24/7, mémoire persistante, support multi-canal (Telegram, Discord, Slack). Inclut Claude Code. |
| `claude-code` | Agent | CLI Claude Code d'Anthropic. Support natif de Bedrock (pas besoin de bedrockify), version épinglée (remplacer sur la machine : `packs/claude-code/install.sh --version latest`), plugins AWS + proxy MCP, permissions complètes sur les outils. |
| `hermes` | Agent *(expérimental)* | Agent CLI Hermes de NousResearch. Compétences auto-améliorantes, boucle d'apprentissage, léger. Utilise bedrockify pour l'accès aux modèles. |
| `pi` | Agent *(expérimental)* | Agent de codage Pi. Harnais de codage terminal minimal avec outils de lecture, écriture, édition, bash. Pure Node.js. |
| `ironclaw` | Agent *(expérimental)* | IronClaw par NEAR AI. Agent basé sur Rust avec outils shell/fichier, support MCP. Binaire statique unique. |
| `nemoclaw` | Agent *(expérimental)* | NemoClaw — OpenClaw dans un bac à sable [NVIDIA OpenShell](https://github.com/NVIDIA/OpenShell) avec isolation Landlock, seccomp et espace de noms réseau. Inférence routée via bedrockify sur l'hôte (pas besoin de clé API NVIDIA). **Uniquement compatible avec le profil `personal_assistant`** — le bac à sable bloque tout accès à l'API AWS. Nécessite Docker + t4g.xlarge. |
| `kiro-cli` | Agent *(expérimental)* | [Kiro CLI](https://kiro.dev/docs/cli) — Client terminal IDE agentique AWS avec support serveur MCP. Utilise sa propre inférence cloud (pas de Bedrock/bedrockify). Pré-installe les serveurs MCP AWS (terraform, ecs, eks, core, docs). **Nécessite une connexion SSO interactive après le déploiement :** `kiro-cli login --use-device-flow`. |
| `codex-cli` | Agent *(expérimental)* | [Codex CLI](https://github.com/openai/codex) — Agent de codage d'OpenAI. Se connecte directement à l'API OpenAI (pas de Bedrock/bedrockify). Configuré comme agent builder (danger-full-access, jamais de prompt). **Étape post-installation** : SSM dans l'instance et exécutez `codex login` (interactif) — l'authentification est intentionnellement reportée après le déploiement. |
| `troika` | Agent *(expérimental)* | Machine de codage à trois harnais : OpenClaw/Hermes + Claude Code + Codex CLI sur une seule instance, tous via Bedrock. Choisissez un **pilote quotidien** qui se lance automatiquement lors de la connexion SSM ; changez à tout moment avec `agents driver <name>`. Réservé aux builders. Nécessite un accès aux modèles Anthropic + accès Bedrock Mantle (`openai.gpt-5.5`). |
| `roundhouse` | Agent | [Roundhouse](https://github.com/inceptionstack/roundhouse) — Agent de codage IA basé sur Pi avec canal Telegram. Utilise le SDK natif Bedrock (pas de bedrockify). Nécessite les paramètres `TelegramBotTokenSecret` et `TelegramUser`. |
### Comment ça fonctionne```
install.sh → picks pack → CloudFormation → EC2 instance
└── bootstrap.sh --pack openclaw --region us-east-1 --model ...
├── Phase 1: System setup (SSM, Node.js, volumes)
├── Writes /tmp/loki-pack-config.json (packs read via jq)
├── Phase 2: Install deps (bedrockify) → Install pack (openclaw/hermes)
└── Phase 3: Brain files, Claude Code, Bedrock check
```
Chaque pack lit uniquement ce dont il a besoin dans le fichier de configuration JSON. Le répartiteur d'amorçage résout automatiquement les dépendances à partir de `packs/registry.yaml`.
### Utilisation autonome des packs
Les packs peuvent également être exécutés individuellement (par exemple, sur une instance EC2 existante) :```bash
# Install bedrockify + hermes manually
git clone https://github.com/inceptionstack/lowkey.git
cd lowkey
# Install bedrockify first (dependency)
bash packs/bedrockify/install.sh --region us-east-1 --port 8090
# Then install your agent pack
bash packs/hermes/install.sh --region us-east-1 --hermes-model anthropic/claude-opus-4.6
# Or for OpenClaw
bash packs/openclaw/install.sh --region us-east-1 --model us.anthropic.claude-opus-4-6-v1 --port 3001
# Or for NemoClaw (sandboxed OpenClaw — needs Docker, personal_assistant only)
bash packs/nemoclaw/install.sh --region us-east-1 --model us.anthropic.claude-sonnet-4-6 --profile personal_assistant
# Or for Kiro CLI (no bedrockify needed, requires interactive login after install)
bash packs/kiro-cli/install.sh --region us-east-1
# Or for Codex CLI (no bedrockify needed, authenticate post-install)
bash packs/codex-cli/install.sh --region us-east-1 --model gpt-5.4
# Then: codex login
```
### Ajout de nouveaux packs
Pour ajouter un nouveau runtime d'agent :
1. Créez `packs/<name>/` avec `manifest.yaml`, `install.sh` et `resources/`
2. Ajoutez le pack à `packs/registry.yaml` avec le type, les dépendances et les exigences d'infrastructure
3. Ajoutez-le aux `AllowedValues` de `PackName` dans le modèle CloudFormation
4. Ajoutez-le au menu de sélection des packs dans `install.sh`
Consultez les packs existants pour le modèle. Chaque `install.sh` doit pouvoir s'exécuter de manière autonome avec des arguments CLI `--key value` et prendre en charge `--help`.
---
## De quoi s'agit-il dans cette expérience ?
Et si vous donniez à OpenClaw son propre compte AWS à gérer et à contrôler, et lui demandiez de construire des choses pour vous ?
## Le problème : l'infrastructure vous fait perdre du temps
Construire un prototype n'a jamais été aussi rapide. Des outils comme Lovable, Base44 et Bolt permettent à tout développeur de passer de l'idée à une démo fonctionnelle en quelques minutes. Pour les applications frontend simples avec des opérations CRUD basiques, ces plateformes offrent une réelle rapidité. Le côté prototype du problème est en grande partie résolu.
Le problème commence dès qu'une équipe décide de construire quelque chose de réel sur AWS. Même les ingénieurs expérimentés qui savent exactement ce qu'ils veulent construire passent des jours sur l'infrastructure avant d'écrire une seule ligne de logique métier : provisionnement du calcul, conception des politiques IAM, configuration du réseau, mise en place des pipelines CI/CD, instrumentation de la surveillance et établissement des bases de sécurité. Pour un fondateur unique ou une petite équipe sans ressources DevOps dédiées, cela peut entraîner d'énormes retards ou signifier ne jamais livrer un produit assez rapidement (ou pas du tout).
L'alternative (ce que font la plupart des fondateurs uniques et des équipes agiles) est de construire rapidement sur une plateforme de développement rapide et de migrer vers AWS plus tard. Cela crée un ensemble différent de problèmes. Ces plateformes sont des « boîtes noires », ne permettent pas d'accéder aux véritables services AWS sauf ce qui est prescrit (si tant est que cela soit possible), et nécessitent des réécritures complètes lorsque les équipes les dépassent. La dette technique s'accumule silencieusement jusqu'à ce que quelqu'un ait besoin d'une intégration de paiement (différente ou plus compliquée), d'une exigence de conformité, ou d'une charge de travail que la plateforme ne peut tout simplement pas prendre en charge (API backend spécialisées ou même un produit uniquement API, schémas ou graphes de données spécialisés, provisions d'échelle spéciales, options de sécurité spécialisées, etc.). À ce stade, l'équipe est confrontée au choix entre une réécriture coûteuse et le fait de rester sur une plateforme qui limite ce qu'elle peut construire.
**Il serait formidable que les développeurs n'aient pas à choisir entre rapidité et contrôle.**
---
## Pourquoi c'est réalisable maintenant
Trois capacités ont convergé pour rendre ce problème résoluble pour la première fois.
**1. Les agents IA qui fonctionnent réellement.** OpenClaw (et d'autres outils similaires), le framework d'agent IA open-source, a prouvé à grande échelle que les utilisateurs (dont certains sont des développeurs) feront confiance à un agent IA pour exécuter des commandes shell, gérer des fichiers et interagir avec des API — lorsque l'agent est compétent et que l'humain garde le contrôle. Il a atteint 317 000 étoiles GitHub en 6 semaines, l'une des courbes d'adoption les plus rapides de l'histoire de l'open-source.
**2. L'infrastructure en tant que code est mature.** aws-cli, Terraform, AWS CDK, CloudFormation, SAM et d'autres outils rendent le provisionnement des ressources entièrement programmable. Un agent IA peut générer, modifier et déployer l'infrastructure en utilisant les mêmes outils qu'un ingénieur humain — produisant un résultat qui est auditable, versionné et réversible.
**3. Les modèles de fondation peuvent raisonner sur l'architecture.** Des modèles comme Anthropic Claude prennent en charge les fenêtres de contexte et la fiabilité d'utilisation des outils nécessaires pour le provisionnement d'infrastructure en plusieurs étapes. Ils peuvent raisonner sur l'architecture d'application full-stack, générer des configurations correctes et maintenir le contexte sur des sessions de construction de plusieurs heures.
Ces trois capacités sont les éléments de base. **Lowkey est ce que vous obtenez lorsque vous les combinez en un seul package déployable, puis que vous lui donnez son propre compte AWS à administrer 24h/24 et 7j/7.**
---
## Ce que fait Lowkey
Lowkey est un agent IA open-source, à déployer soi-même, qui vit dans votre compte AWS (généralement un par compte pour que les agents ne se marchent pas sur les pieds) et construit du code réel, de l'infrastructure, des déploiements et des configurations.
Clonez le dépôt, déployez via CloudFormation, et en quelques minutes vous avez un agent 24h/24 et 7j/7 opérant dans votre compte, connecté à Amazon Bedrock (par défaut, vous pouvez le changer), chargé de compétences en infrastructure AWS, et prêt à construire. L'agent est accessible via Telegram, Discord, Slack ou une interface utilisateur terminal, et conserve une mémoire complète entre les sessions, de sorte qu'il sait toujours ce qu'il a construit, ce qui est déployé et dans quel état se trouve chaque chose.
Lowkey gère le cycle de vie complet de la construction dans votre compte AWS :
* **Conçoit et déploie** des API sans serveur, des charges de travail conteneurisées et des pipelines de données
* **Écrit le code applicatif**, le pousse vers les dépôts et déclenche les pipelines CI/CD
* **Configure les politiques IAM**, les groupes de sécurité et la journalisation
* **Met en place la surveillance CloudWatch** et peut activer les services de sécurité AWS (GuardDuty, Security Hub, etc.) sur demande
* **Dépanne les problèmes de production** — lit les logs CloudTrail, identifie les causes racines et applique les correctifs
Tout ce que Lowkey construit peut utiliser (mais sans s'y limiter) les services AWS standard : CloudFormation ou CDK ou Terraform pour l'infrastructure, CodeCommit ou GitHub pour le code, Lambda ou ECS pour le calcul, DynamoDB ou RDS pour les données. Il n'y a pas d'environnement d'exécution propriétaire, pas de couche d'abstraction et aucune migration requise lorsque votre application dépasse le stade du prototype.
**Vous possédez tout.** Désactivez Lowkey demain et vos applications continuent de fonctionner. Chaque ressource est visible dans la console AWS, portable vers n'importe quelle chaîne d'outils et modifiable par vous.
### Différence par rapport à Cursor, Claude Code, Kiro et autres
Contrairement aux **outils de codage IA** (Cursor, Kiro, Claude Code) qui s'exécutent sur votre ordinateur portable et s'arrêtent lorsque celui-ci se ferme, Lowkey est un agent persistant qui vit dans votre compte AWS 24h/24 et 7j/7. Commencez une construction mardi, revenez jeudi, et il sait exactement où en sont les choses.
### Différence par rapport à Lovable, Bolt, Base44 etc.
Contrairement aux **plateformes de développement rapide** (Replit, Lovable, Bolt) qui font abstraction de l'infrastructure et emprisonnent votre code dans des environnements d'exécution propriétaires, Lowkey fonctionne *au sein* d'AWS. Votre infrastructure est réelle, gérée par des outils IaC standard, sans verrouillage par un fournisseur externe (sauf AWS bien sûr, mais vous pouvez choisir de construire des applications entièrement conteneurisées afin de pouvoir les porter facilement à l'avenir).
### Différence par rapport aux assistants OpenClaw standard
Contrairement à un **assistant IA généraliste**, Lowkey est livré avec des compétences en infrastructure AWS et les autorisations IAM nécessaires pour provisionner réellement les ressources. Il est spécialement conçu pour construire et opérer sur AWS. **Au lieu d'être complètement confiné dans un bac à sable VM ou Docker, son bac à sable est défini par les limites du compte AWS dans lequel il vit.**
Il ne regroupe aucune compétence clawhub (énorme risque de sécurité), mais est livré principalement avec des compétences AWS et Playwright MCP via mcporter.
---
## Lowkey en action
Captures d'écran réelles provenant d'une utilisation réelle — construction d'applications, débogage d'infrastructure et surveillance des ressources AWS.
### De l'invite à l'application déployée
Décrivez ce que vous voulez en langage naturel. Lowkey planifie l'architecture, écrit le code, met en place le CI/CD et déploie — le tout pendant que vous regardez ou que vous faites autre chose.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/41ba181c2fb93b455731117d1410e51996940b8ae97527335555c19cfe54a901.jpg" alt="Lowkey construisant une application full-stack à partir d'une invite conversationnelle" width="700" />
</p>
### Planification de l'architecture avant d'écrire du code
Avant de toucher au code, Lowkey expose un plan d'architecture complet — modèle de données, flux de trafic, composants d'infrastructure et stratégie de déploiement. Vous examinez et ajustez avant qu'il ne commence à construire.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/4617985c9dc355a418816fe096defc59fd676e2e7c73f78b28427f8fa857a8b4.jpg" alt="Lowkey planifiant une architecture complète avec modèle de données, flux de trafic et infrastructure" width="700" />
</p>
### Travaillez de n'importe où — il se souvient de tout
Reprenez là où vous vous êtes arrêté depuis n'importe quel appareil. Lowkey a une mémoire complète de chaque projet, de chaque décision, de chaque ressource déployée. Pas de taxe de changement de contexte.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/d24deb49c56656d16c728d4ca681c16fc5601eb3c3835f75efe281bd5101f7c5.jpg" alt="Poursuite d'une conversation depuis un téléphone — Lowkey se souvient du contexte complet du projet" width="500" />
</p>
### Briefing matinal proactif
Lowkey n'attend pas que vous demandiez. Il envoie des rapports quotidiens couvrant les coûts AWS, les constats de sécurité, les CVE critiques et l'état des pipelines — avant même que vous n'ouvriez votre ordinateur portable.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/4daabc8a6ddbbd6e109ca937c9273a8235dc9732f0d14bec226e0dd199397904.jpg" alt="Briefing matinal Lowkey — coûts AWS, constats de sécurité, CVE, état des pipelines" width="500" />
</p>
### Détection et correction de CVE
Lowkey peut lire depuis Security Hub, GuardDuty et Inspector. Lorsqu'il trouve des rapports de CVE, il peut proposer des correctifs, reconstruire les images conteneur et vérifier le résultat. **Il s'agit d'une fonctionnalité de commodité, pas d'une garantie de sécurité — examinez toujours ce qu'il fait.**
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/48cc47b695c472f403c53e79fd38e6164bd8d59656cdb204725579baac07074b.jpg" alt="Lowkey détectant 1 constat CRITIQUE + 19 constats ÉLEVÉS et proposant des correctifs" width="400" />
<img src="https://assets.kitploit.com/production/public/readmes/7172/f5828748e139807138dba351934c795102f08d72b7a5107d5cd74b5958d28a32.jpg" alt="Lowkey vérifiant que toutes les CVE sont éliminées après correction autonome" width="400" />
</p>
<p align="center"><em>Gauche : l'agent détecte des CVE pendant la nuit. Droite : toutes les CVE éliminées, application vérifiée fonctionnelle.</em></p>
### Débogage autonome
Quand quelque chose se casse, Lowkey trace le problème à travers les VPC, les équilibreurs de charge, les tables de routage et le DNS — puis le corrige et vous dit ce qui s'est passé.
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7172/f5803f1c309147a23ac1450651ea94b3f821456d1b26d1513bcbd00c6001793e.jpg" alt="Lowkey trouvant et corrigeant de manière autonome des problèmes de routage VPC et d'écouteur ALB" width="500" />
</p>
---
## Une journée avec Lowkey
Lowkey n'est pas un outil ponctuel que vous ouvrez quand vous avez besoin de quelque chose. C'est un partenaire toujours actif qui vit dans votre compte AWS 24h/24 et 7j/7 — codant, déployant, surveillant et améliorant pendant que vous vous concentrez sur ce qui compte.
| | Heure | Ce qui se passe |
|---|---|---|
| 🌅 | **8h00** | **Le briefing matinal arrive.** Avant d'ouvrir votre ordinateur, Lowkey envoie un rapport quotidien : résumé des constats de sécurité, dépenses de la nuit (3,20 $), CVE signalées dans vos images conteneur, tous les pipelines au vert. |
| ☕ | **9h30** | **Vous avez une idée.** Via le terminal SSM : *"Construis-moi une API REST sans serveur avec DynamoDB, authentification Cognito et un frontend React."* Le temps de finir votre café — c'est en ligne, avec des tests, un pipeline CI/CD et des alarmes CloudWatch. Tout en IaC. |
| 🛡️ | **11h00** | **Lowkey signale quelque chose.** Un contrôle de routine détecte un groupe de sécurité trop permissif. Lowkey propose de le resserrer, met à jour le modèle CloudFormation et vous envoie un résumé à examiner. |
| 📱 | **14h15** | **Itérez depuis n'importe où.** Message depuis votre téléphone : *"Ajoute un endpoint WebSocket à l'API que j'ai construite ce matin."* Lowkey se souvient de toute l'architecture — aucun besoin de contexte. |
| 📋 | **17h30** | **Résumé de fin de journée.** *"Résume tout ce que nous avons construit aujourd'hui."* Lowkey récapitule : 2 nouveaux services déployés, 14 ressources CloudFormation créées, 3 pipelines configurés, tous les tests réussis. Copiez-collez à votre équipe. |
| 🌙 | **3h00** | **Pendant que vous dormez.** Des tâches planifiées peuvent auditer votre infrastructure par rapport aux bonnes pratiques AWS. Lowkey trouve des optimisations de coûts et signale des améliorations, enregistrant tout pour votre examen matinal. |
---
## Comment ça fonctionne
Lowkey est construit sur [OpenClaw](https://github.com/openclaw/openclaw), le framework d'agent IA open-source. Le dépôt [lowkey](https://github.com/inceptionstack/lowkey) regroupe tout ce qui est nécessaire pour déployer une instance Lowkey prête pour la production :
**1. Déploiement en un clic.** Déployez le modèle CloudFormation. Il crée un VPC isolé, une instance EC2 T4g.xlarge par défaut (recommandée pour qu'elle puisse vraiment faire des choses comme exécuter des tests, construire du code, dockeriser des éléments, etc., comme une vraie machine de développement), des rôles IAM, des services de sécurité et installe Lowkey avec un espace de travail préconfiguré. Temps de déploiement total : ~4-10 minutes.
**2. Surveillance configurable.** Le déploiement inclut cinq services de sécurité AWS activables individuellement — Security Hub, GuardDuty, Inspector, Access Analyzer et AWS Config — tous activés par défaut. Pour les environnements de test/développement, désactivez ce dont vous n'avez pas besoin. L'instance EC2 utilise SSM Session Manager au lieu de SSH (aucun port ouvert), et la passerelle Lowkey écoute uniquement sur localhost (non exposée au réseau). **Remarque :** L'activation de ces services ne rend pas l'agent lui-même sécurisé — cela signifie que l'agent peut remonter les constats de ces outils. Vous êtes toujours responsable de leur examen et des actions à entreprendre.
**3. Observer → Planifier → Agir.** Lowkey lit l'état actuel de votre compte AWS, planifie les actions suivantes et les exécute avec tous les pouvoirs d'administration. **(rappelez-vous – un grand pouvoir implique de grandes responsabilités. C'est risqué, alors utilisez-le sur un compte AWS propre pour minimiser le rayon d'explosion en cas d'erreur de l'agent)**
---
[Read more](https://github.com/inceptionstack/lowkey)