En résumé : Les agents IA de Pokee s'exécutent via l'API Pokee Enterprise : chaque client (tenant) bénéficie d'un bac à sable (sandbox) privé et persistant dans lequel un agent peut travailler sur une même tâche (turn) pendant une durée maximale de 90 minutes. Il dispose d'un accès aux fichiers restreint, de compétences (skills) téléversées, de fichiers de persona dans .pokee/ et d'une mémoire conservée d'une session à l'autre. L'API prend en charge l'exécution de l'agent. Votre équipe, en revanche, a toujours besoin d'un espace centralisé pour lui assigner ces tâches, suivre sa progression et valider le résultat avant toute mise en production.
Pokee est conçu pour les tâches qui dépassent les capacités d'une simple fenêtre de discussion : la rédaction d'un rapport de marché de dix pages, une recherche approfondie nécessitant près d'une heure de calcul, etc. Personne ne reste devant son écran à surveiller une tâche de 90 minutes ; il faut donc que quelqu'un en assume la responsabilité, vérifie le travail produit et en valide l'achèvement. Si vous pilotez déjà des agents de développement sur un tableau Kanban, Sharkly est précisément l'endroit où centraliser ces flux de travail — nous y reviendrons plus bas.
Qu'est-ce que Pokee AI ?
Pokee est une plateforme d'agents dont l'API Enterprise se définit comme « une API REST permettant d'exécuter des flux de travail agentiques de longue durée au sein d'un bac à sable persistant et dédié ». Chaque client dispose d'un espace de travail privé, d'un jeton d'authentification Bearer et de points de terminaison pour gérer les sessions, les fichiers, les compétences ainsi que le streaming des messages à une adresse de type https://your-tenant.enterprise.pokee.ai. L'accès est réservé aux entreprises : la documentation de Pokee redirige les nouveaux utilisateurs vers une « demande de démo » et ne fait mention d'aucune offre en libre-service ou gratuite.
Deux niveaux de modèles sont détaillés sur la page des modèles et des tarifs :
| Modèle | Entrée ($/M de tokens) | Sortie ($/M de tokens) | Lecture du cache ($/M de tokens) |
|---|---|---|---|
pokee-isaac-high-reasoning |
3 $ | 15 $ | 0,30 $ |
pokee-isaac |
0,30 $ | 5 $ | 0,10 $ |
Par défaut, les nouveaux clients sont configurés sur le niveau à raisonnement avancé (high-reasoning). Le modèle est verrouillé dès la création de la session : chaque interaction au sein de celle-ci utilisera donc le même niveau.
L'architecture de l'agent Pokee : sessions, sandbox, fichiers, compétences et mémoire
Le modèle d'agent de Pokee repose sur cinq composants configurables, chacun correspondant à un choix opérationnel pour votre équipe.
- Sessions. Une session correspond à un processus agent exécuté dans son propre bac à sable, au sein de votre pod dédié, avec son propre historique, ses autorisations de fichiers et son état d'activité.
- Mode persistant. Par défaut, une session s'autodétruit 5 minutes après sa dernière réponse. En définissant
persistent: true, elle reste active jusqu'à expiration de son TTL (4 heures par défaut) ou jusqu'à ce que vous la supprimiez. - Accès aux fichiers restreint (scope). Vous spécifiez les chemins d'accès en
read(lecture) etwrite(écriture) lors de la création. Les répertoires situés hors de ce périmètre n'existent tout simplement pas dans le système de fichiers de l'agent. - Compétences (skills). Il vous suffit de téléverser une archive zip contenant un fichier
SKILL.mdà sa racine. Chaque nouvelle session du client y a immédiatement accès. - Fichiers de persona et mémoire. Les fichiers Markdown placés dans
.pokee/sont ajoutés en en-tête du prompt système, tandis que.memory/MEMORY.mdassure la persistance des informations d'une session à l'autre.
Comment Pokee restreint-il l'accès aux fichiers ?
Le cloisonnement est appliqué à deux niveaux. Au cœur de l'agent, un espace de noms de montage bubblewrap propre à la session masque l'ensemble des répertoires extérieurs aux chemins autorisés ; une tentative de lecture renvoie donc une erreur ENOENT. Via l'API de fichiers HTTP, la même requête renvoie une erreur 403 Forbidden.
Le guide pratique sur l'accès restreint aux fichiers illustre une session autorisée à lire le dossier d'un client ainsi qu'un répertoire de modèles partagés, tout en limitant les droits d'écriture au seul dossier de sortie de ce client :
curl -X POST "$POKEE_API/v1/sessions" \
-H "Authorization: Bearer $POKEE_KEY" \
-H "Content-Type: application/json" \
-d '{
"persistent": true,
"ttl": 14400,
"metadata": {"board_task": "COIN-412", "client": "acme-corp"},
"file_access": {
"read": ["projects/acme-corp", "shared/templates"],
"write": ["projects/acme-corp/output"]
}
}'
Ce périmètre d'accès est immuable pendant toute la durée de vie de la session. Pour l'élargir, vous devez détruire la session et en recréer une. Cette contrainte renforce la conformité et responsabilise l'équipe : le périmètre doit être défini au moment de l'attribution de la tâche, et non en plein milieu de son exécution.
À quoi servent les fichiers de persona .pokee/ et la mémoire ?
Les fichiers situés dans workspace/.pokee/*.md sont chargés par ordre alphabétique dans le prompt système, chacun sous un titre de type ## <nom_du_fichier>. Le guide pratique sur les personas utilise par exemple 00_soul.md pour le ton, 10_glossary.md pour le lexique métier et 20_style_guide.md pour les règles de mise en page. La taille totale de ce répertoire est plafonnée à 1 Mo.
Les modifications apportées prennent effet à la session suivante ; une session en cours d'exécution conserve son prompt initial. L'agent lit et met également à jour .memory/MEMORY.md à chaque session. Vous pouvez modifier ce fichier via l'API de fichiers ou, comme indiqué sur la page dédiée au contexte de l'agent, demander à Pokee de désactiver cette fonctionnalité.
L'impact des agents IA de longue durée sur l'organisation des équipes
L'utilisation d'agents IA exécutant des tâches longues transforme trois aspects du quotidien d'une équipe : qui lance le travail, comment en suivre l'avancement et qui valide le livrable final. Les limites par défaut de Pokee rendent ces problématiques très concrètes.
| Limite | Valeur par défaut |
|---|---|
| Sessions simultanées | 10 |
| Délai d'expiration par tour (turn timeout) | 90 minutes |
| TTL de session | 4 heures |
| Tours par heure / par jour | 300 / 5 000 |
| Tokens par heure / par jour | 20 M / 200 M |
| Taille maximale de l'espace de travail | 100 Go |
Pokee précise que chacune de ces limites peut être relevée sur simple demande.
Qui assigne une tâche d'agent de 90 minutes ?
Pouvoir faire tourner dix sessions en parallèle semble largement suffisant, jusqu'au lundi matin où cinq collaborateurs lancent chacun la génération de deux rapports volumineux. De plus, une session occupée rejette tout nouveau message avec une erreur 409. Il est donc indispensable qu'une personne se charge de définir la tâche, le modèle, les autorisations d'accès aux fichiers et la session, puis consigne tout cela sur un ticket assorti d'un responsable. Cela évite notamment que deux personnes ne lancent la même génération de 90 minutes en double.
Comment suivre l'avancement d'un agent pendant une longue exécution ?
L'agent poursuit son exécution même si votre client se déconnecte. Le guide pratique sur les tâches de longue durée propose d'interroger GET /v1/sessions/{id} toutes les 15 secondes pour vérifier le drapeau busy, lire les indicateurs de progression inscrits dans les metadata par le workflow, puis télécharger le fichier produit.
while True:
s = c.get(f"/v1/sessions/{sid}").json()
if not s["busy"]:
break
print(f"metadata: {s['metadata']}")
time.sleep(15)
Le flux d'événements s'appuie quant à lui sur les Server-Sent Events, avec les événements message.created, message.completed, message.error et message.cancelled. Le point de terminaison de reprise (resume) permet de se reconnecter à un flux interrompu à partir du Last-Event-ID sans facturation supplémentaire de tokens. Ces mécanismes indiquent à votre script que le traitement est terminé, mais ils ne disent rien sur la qualité du rapport produit.
Qui valide le livrable avant sa diffusion ?
Pokee se contente d'écrire un fichier dans l'espace de travail. L'étape de relecture reste une démarche humaine extérieure à l'API : quelqu'un doit ouvrir report.md, s'assurer de sa conformité avec le brief de départ, puis valider le document ou demander des corrections. Dès lors que plusieurs agents travaillent en parallèle, cette étape devient bien souvent le principal goulet d'étranglement, comme nous le soulignons dans notre article la révision humaine comme goulot d'étranglement.

Cas pratique : cycle complet d'un rapport client, du cadrage à la validation
Prenons l'exemple de trois collaborateurs partageant le même environnement Pokee. Le livrable attendu est une étude de marché trimestrielle pour le compte de l'entreprise « Acme Corp ».
- Assigner. Dana crée un ticket : « Étude de marché T3 pour Acme », responsable Dana, relecteur Sam, échéance jeudi.
- Cadrer. Le ticket précise le modèle Pokee à utiliser (
pokee-isaac-high-reasoning), les répertoires de lecture autorisés (projects/acme-corp,shared/templates) et le répertoire d'écriture (projects/acme-corp/output). - Lancer. Dana initialise une session persistante en renseignant l'identifiant du ticket dans les
metadata, puis envoie un message demandant la génération du rapport dansoutput/report.md. - Suivre. L'ID de session est consigné en commentaire du ticket. Toute personne interrogeant
GET /v1/sessions/{id}constatera le statutbusy: truejusqu'à la fin du traitement. - Récupérer. Dès que l'indicateur
busyrepasse à faux, Dana télécharge le fichier généré et le joint au ticket. - Valider. Sam examine le livrable au regard du cahier des charges. En cas d'écart, le document est renvoyé avec des retours pour une nouvelle itération ; si le résultat est conforme, la tâche franchit l'étape suivante.
- Nettoyer. Dana supprime la session, ou laisse une tâche nocturne exécuter
DELETE /v1/sessions?status=idle&older_than=1hpour faire le ménage.
Les étapes 1, 4 et 6 ne font intervenir aucun appel d'API. Elles relèvent purement de la coordination d'équipe — précisément les étapes que l'on a tendance à négliger quand un agent répond en quelques secondes, mais dont l'absence se paie cher quand le traitement dure une heure.
Comment Sharkly s'articule avec les agents Pokee
Sharkly est une plateforme de gestion du travail pour agents : un tableau unique où les tâches sont réparties entre humains et agents, où les exécutions sont supervisées et où les résultats attendent la validation d'un relecteur. Sharkly n'exécute pas directement vos sessions Pokee et n'intègre pas de connecteur natif Pokee. La plateforme structure en revanche l'ensemble du flux : la tâche, son responsable, son statut et les phases d'approbation associées.
Concrètement, voici comment cela fonctionne :
- Attribution des tâches. La tâche Pokee est matérialisée sur le tableau avec un responsable désigné et un statut clair, aux côtés des autres projets de l'équipe. Consultez notre article sur les équipes agentiques pour comprendre pourquoi la responsabilisation doit être explicite.
- Un agent qui pilote l'API. Un agent Sharkly tourne directement sur votre propre machine via un environnement d'exécution (runtime) tel que Claude Code. En lui attribuant une compétence (skill) encapsulant les requêtes curl présentées plus haut, il peut créer la session de manière autonome, en suivre le statut et consigner l'identifiant ainsi que le résultat final directement dans le ticket.
- Des limites d'exécution alignées sur celles de Pokee. Chaque agent dispose de paramètres d'exécution précis : nombre maximal de tâches simultanées, durée maximale par tâche et délai d'expiration de la file d'attente. L'agent illustré ci-dessous est ainsi bridé à 1 tâche et 40 minutes ; pour vos flux Pokee, veillez à ne pas dépasser votre plafond de 10 sessions simultanées et prévoyez une durée suffisante pour couvrir les 90 minutes d'exécution, ou configurez l'agent pour qu'il initie la tâche et vienne relever le résultat plus tard.

- La révision vue comme un statut, et non comme un simple message. Un agent peut passer une tâche à l'état « en attente de validation humaine », ce qui la fait automatiquement remonter dans la boîte de réception du relecteur. Nos articles sur l'intervention humaine dans les agents de code et les points d'approbation pour les agents de développement expliquent en détail comment positionner ces points d'arrêt.
- Déclencheurs externes. Les automatisations Sharkly peuvent être activées par webhook : une URL sécurisée déclenche une exécution dès qu'un service externe y envoie une requête POST. Votre propre script peut ainsi l'appeler automatiquement dès qu'un traitement Pokee prend fin.
Sharkly est accessible gratuitement pour démarrer, et la consommation de vos modèles reste imputée sur vos comptes habituels. Pour approfondir ces logiques de validation sur les exécutions longues, découvrez pourquoi les traitements à plusieurs millions de tokens nécessitent une file de révision.
Quand choisir Pokee (et quand s'en passer)
Pokee est tout indiqué lorsque votre projet vise à produire un document ou un jeu de données plutôt qu'une modification de code source, que le traitement s'étend sur plusieurs dizaines de minutes et qu'un bac à sable persistant est nécessaire. C'est également une excellente solution si vos engagements contractuels stipulent expressément que « l'agent ne doit en aucun cas accéder aux données du client B », puisque l'isolation est garantie au niveau du système de fichiers. Son mode hors ligne permet par ailleurs de configurer un environnement dont l'unique flux sortant autorisé est l'API du modèle.
En revanche, tournez-vous vers d'autres solutions si vous souhaitez démarrer immédiatement sans passer par une démonstration commerciale. Pour travailler directement au sein de vos propres dépôts de code, des outils comme Claude Code ou Codex déployés sur vos propres machines répondront mieux à vos besoins. De nombreuses équipes font d'ailleurs cohabiter les deux approches, ce qui justifie d'autant plus de les piloter depuis un tableau de bord commun.
Conclusion
Les agents IA de Pokee permettent aux équipes de déléguer des tâches de longue haleine tout en profitant d'un véritable cloisonnement des données. L'API répond à la question : « Le traitement est-il terminé ? ». En revanche, c'est toujours à votre équipe de déterminer qui a lancé la tâche, quelles ressources ont été sollicitées et si le résultat est conforme aux attentes.
Définissez clairement ces trois réponses sur votre ticket avant même d'initialiser la première session. Si vous souhaitez centraliser sur un même tableau vos flux Pokee et vos agents de développement, créez un espace de travail Sharkly et confiez dès cette semaine votre première tâche longue durée à un agent.
FAQ
Qu'est-ce que l'API Pokee Enterprise ?
L'API Pokee Enterprise est une interface REST conçue pour exécuter des flux de travail agentiques complexes au sein d'un bac à sable persistant et dédié par client. Elle met à votre disposition des points de terminaison pour gérer les sessions, les fichiers, les compétences, la consommation et les flux de messages en temps réel, le tout sécurisé par un jeton Bearer.
Combien de temps un agent Pokee peut-il s'exécuter ?
Une tâche (turn) peut tourner jusqu'à 90 minutes par défaut, et une session peut rester active jusqu'à 4 heures. Ces deux plafonds peuvent être augmentés sur demande.
Pokee AI est-il gratuit ?
La documentation n'indique pas d'offre gratuite. L'accès nécessite une prise de contact via une demande de démo, et la facturation se fait au token : 3 $ en entrée et 15 $ en sortie par million de tokens pour pokee-isaac-high-reasoning, contre 0,30 $ et 5 $ pour pokee-isaac.
Que se passe-t-il si deux personnes envoient un message à la même session Pokee ?
Le second message se solde par une erreur 409, la session étant déjà occupée par le premier traitement. Chaque session ne traite qu'une tâche à la fois ; les tâches simultanées doivent donc être réparties sur des sessions distinctes, dans la limite de 10 par défaut.
Un agent Pokee peut-il mémoriser des informations d'une session à l'autre ?
Oui. Il consulte et met à jour le fichier workspace/.memory/MEMORY.md à chaque session, et ce fichier est conservé même lors du redémarrage du pod.
Sharkly peut-il exécuter des agents Pokee directement ?
Non. Sharkly ne dispose pas d'un connecteur dédié pour Pokee. En revanche, un agent Sharkly exécuté sur votre machine peut tout à fait piloter l'API Pokee via une compétence personnalisée, tandis que le ticket Sharkly centralise l'affectation, le suivi du statut et la validation humaine.



