Le runtime, écrit en Rust

Un moteur qui tourne chez vous, vos agents en Python dessus.

Apollia OS s’installe comme n’importe quel logiciel, et laisse derrière lui un programme qui tourne en fond, sans fenêtre : c’est lui qui parle au modèle d’IA, qui exécute les outils, qui applique vos règles et qui compte les étapes.

Trois portes, un seul moteur, et il est sur votre disque.

Le périmètre exact de la préversion

0.2.0-preview · Rust et Python · Apache 2.0 ou MIT

veille.py Python
from apollia import agent, skill
from apollia.types import Ctx


@agent(name="veille", version="0.1.0", description="Résume une page pour vous.")
class Veille:
    @skill("veille.resumer", description="Résume une page web en cinq points.")
    async def resumer(self, url: str, ctx: Ctx) -> str:
        page = await ctx.tools.call("web_read", {"url": url})
        reponse = await ctx.llm.chat("Résume en cinq points.", page["content"])
        return reponse.content
Un agent Apollia complet : une classe Python, un décorateur au-dessus, une méthode asynchrone dedans, rien à hériter. Ce que fait chaque morceau
VOTRE PREMIER AGENT

Un agent complet tient en dix lignes.

Voici le fichier de l’accroche, cette fois annoté. Ce n’est pas un extrait choisi pour la démonstration, c’est le fichier entier, et chacun de ses morceaux est expliqué en face.

  • @agent

    Le décorateur posé sur la classe. Il porte le nom, la version, la description, et ce dont l’agent a besoin pour travailler.

  • @skill

    Une capacité, avec son identifiant. Le schéma des paramètres est déduit de la signature de votre méthode.

  • ctx

    Le contexte que le runtime glisse dans votre méthode. Quinze services y sont déjà branchés. Vous n’en instanciez aucun.

  • L’agent d’exemple, dans le dépôt Le guide pas à pas du premier agent
veille.py Python
from apollia import agent, skill
from apollia.types import Ctx


@agent(name="veille", version="0.1.0", description="Résume une page pour vous.")
class Veille:
    @skill("veille.resumer", description="Résume une page web en cinq points.")
    async def resumer(self, url: str, ctx: Ctx) -> str:
        page = await ctx.tools.call("web_read", {"url": url})
        reponse = await ctx.llm.chat("Résume en cinq points.", page["content"])
        return reponse.content
CE QUI TOURNE PENDANT QUE VOUS TRAVAILLEZ

Un programme en fond, deux qu’il surveille, un dossier sur votre disque.

Il n’y a pas de quatrième pièce, pas de service qui se réveille ailleurs, pas de compte à rattacher. Voici les trois, dans l’ordre où elles comptent pour vous.

Ce qui tourne sur votre machine quand Apollia tourne. Aucun service distant à l’autre bout, aucun compte à créer avant de commencer.

Le journal Ce qu’un agent fait est écrit dans un registre en ajout seul, chaîné par hachage et signé. Ce qu’il prouve, et ce qui le borne

En détail Les briques du système, dans la documentation

Ce que ça change que tout ça tourne chez vous

TROIS FAÇONS DE LUI PARLER

Au clic, au clavier, ou depuis vos propres programmes.

Le choix n’engage à rien : les trois portes ouvrent sur le même moteur, avec les mêmes règles et le même journal.

  1. L’application de bureau

    Tauri 2 · Svelte 5

    C’est la porte par défaut, celle qui s’ouvre après l’installation et qui vous fait choisir votre modèle. Vous y conversez, vous y branchez vos comptes, vous y réglez ce qu’un agent a le droit de faire et ce qu’il a le droit de retenir.

  2. La ligne de commande

    apollia-os · --json

    Le binaire s’appelle apollia-os. Quarante familles de commandes, cent quatre-vingt-dix-neuf commandes invocables, nommées en objet puis verbe, ce qui se devine plus que ça ne s’apprend.

    Un drapeau --json, accepté à n’importe quelle position, rend une sortie faite pour être lue par un programme plutôt que par vous.

  3. Votre propre code

    127.0.0.1:7771 · socket local

    C’est la porte des intégrateurs, et c’est exactement la même que les deux autres empruntent : l’application et le terminal parlent à cette interface. Cent neuf routes HTTP, décrites par une spécification OpenAPI produite depuis le code plutôt qu’entretenue à côté.

    Deux entrées. Un socket de fichier, où ce sont les droits du système qui font le travail. Et le port local 7771, où un jeton est obligatoire, l’équivalent d’un mot de passe.

Et une exécution n’a pas besoin de vous pour partir.

Une heure de la journée, un intervalle régulier, une seule fois à une date, un fichier qui arrive dans un dossier surveillé, ou un appel entrant dont la signature est vérifiée.

ENTRE VOTRE PHRASE ET LE RÉSULTAT

Il enchaîne tout seul, il demande avant ce qui compte, il s’arrête où vous avez dit.

Trois mécanismes, dans l’ordre où ils s’appliquent.

La boucle
et il repart d’en haut
  1. Il lit
  2. Il choisit un geste
  3. Apollia exécute, ou vous demande
  4. Il relit le résultat

Il s’arrête : réponse rendue, ou limite atteinte.

Quatre temps qui se répètent : il lit, il choisit un geste, Apollia l’exécute ou vous demande votre accord, il relit le résultat. La boucle s’arrête quand la réponse est rendue, ou quand la limite que vous avez posée est atteinte.
  1. Il lit

    Votre demande, ce qu’il a déjà fait, et les outils qu’il a le droit d’appeler.

  2. Il choisit un geste

    Plutôt que de vous répondre, il réclame un outil.

  3. Apollia exécute, ou vous demande

    Vos règles sont relues à cet instant précis. Si aucune ne couvre l’appel, tout s’arrête et attend votre accord.

  4. Il relit le résultat

    Il en tire la suite, et il recommence, ou il vous rend sa réponse.

La décision, à chaque appel d’outil
  1. Vos règles d’abord. Elles sont relues à chaque appel, pas au démarrage de la conversation.
  2. Un refus l’emporte. Toujours, y compris sur un outil que vous aviez autorisé par ailleurs.
  3. Une autorisation exécute directement.
  4. Et si rien ne tranche, la question vous revient.

Deux outils échappent à toute simplification : celui qui lance une commande et celui qui exécute du Python. Ceux-là vous sont demandés à chaque fois.

Les trois limites, et c’est vous qui les posez
Le nombre d’étapes
Combien de fois il a le droit de réfléchir avant de rendre la main.
Le nombre d’appels d’outils
Combien de gestes il a le droit de faire en tout.
La durée
Le temps au bout duquel l’exécution s’arrête, finie ou pas.
Étapes 10 restant
Appels d’outils 10 restant
Temps 10 s restant

Trois limites, comptées par Apollia et hors de portée de l’agent : le nombre d’étapes, le nombre d’appels d’outils, la durée. Quand l’une atteint zéro, l’exécution s’arrête, finie ou pas. Les chiffres sont ceux de l’exemple ; les vôtres se règlent dans l’application.

Une chose à savoir avant d’installer un agent qui n’est pas de vous : ce point de contrôle couvre la conversation. Un agent installé qui appelle ses outils lui-même ne le rencontre pas. Apollia le borne, il ne l’enferme pas, et la règle pratique tient en une phrase : n’installez que des agents que vous avez écrits, ou dont vous avez lu le code.

Ce qu’un agent fait, en langage courant

CE SUR QUOI UN AGENT PEUT AGIR

Des outils dans le binaire, vos comptes au-dessus, le reste par un standard.

Dix-huit outils natifs sont enregistrés au démarrage, et le modèle sait s’en servir dès la première conversation.

FamilleOutilsCe qu’ils font
Vos fichierssixLire, écrire, modifier, lister, chercher par nom ou par contenu.
Exécuter du codedeuxUne commande, un script Python. Votre accord à chaque appel.
Le webdeuxUne recherche, puis la lecture de la page trouvée.
Vos règlestroisAjouter, retirer et lister les règles de permission.
Les carnets JupyterdeuxLire un carnet, en modifier une cellule.
Sa mémoireunRetrouver ce qu’il a noté, en plein texte.
VousunQuand une information lui manque, il vous la demande au lieu de deviner.

Au-dessus, vos comptes.

Cinquante et une opérations sur Google Workspace et Microsoft 365. La connexion se fait depuis l’application, en cliquant, et votre mot de passe ne passe jamais par Apollia.

Et le reste de vos outils, par un standard.

Apollia parle MCP. Dix-huit intégrations arrivent préconfigurées, et le catalogue public du standard se parcourt depuis l’application.

La référence des outils natifs Les comptes, le catalogue, et comment ils se relient

SI VOUS ÉCRIVEZ LE VÔTRE

Quatre décorateurs, quinze services, aucune bibliothèque à installer.

Le kit de développement n’a aucune dépendance tierce : ce que vous installez pour écrire un agent, c’est Python et rien d’autre.

  • @agent sur la classe

    Le nom, la version, la description, et ce que l’agent déclare avoir besoin pour travailler.

  • @skill sur une méthode

    Une capacité identifiée, appelable par vous, par un déclencheur, ou par un autre agent.

  • @on_message sur une méthode

    La réponse dans une conversation, avec l’historique du fil en paramètre.

  • @orchestrated sur une méthode

    Pour un agent qui établit un plan avant d’agir plutôt que d’enchaîner ses gestes au fil de l’eau.

Et le contexte que reçoit votre méthode

Un seul paramètre, ctx, et quinze services derrière. Vous n’en instanciez aucun, vous n’en configurez aucun, et vous n’avez pas à savoir lequel parle à quoi.

  • ctx.llm Le modèle : une réponse, un flux, ou un lot.
  • ctx.memory Ce qu’il a noté, retrouvé en plein texte.
  • ctx.tools Les outils, natifs et branchés.
  • ctx.a2a Appeler la compétence d’un autre agent.
  • ctx.mail Déposer un message à un autre agent, sans l’attendre.
  • ctx.datasources Les jeux de données déclarés dans le décorateur.
  • ctx.templates Les gabarits de texte déclarés, rendus avec ses variables.
  • ctx.secrets Un secret, lu au moment de s’en servir.
  • ctx.events Publier sur le flux que l’interface écoute en direct.
  • ctx.logger Écrire dans le journal du runtime.
  • ctx.profile Ce que vous avez dit de vous.
  • ctx.workspace Les règles du dossier de travail.
  • ctx.stt Transcrire un son en texte.
  • ctx.notify Vous prévenir sur votre bureau.
  • ctx.budget Ce qu’il lui reste d’étapes. En lecture seule, et c’est le point.

La référence complète du kit, service par service

AVANT DE CONSTRUIRE DESSUS

Ce que la 0.1.0 couvre, et jusqu’où.

Un produit jeune ne coûte rien. Ce qui coûte, c’est de découvrir sa frontière une fois qu’on a bâti dessus. Voici les quatre qui comptent, dites maintenant plutôt que dans trois semaines.

Du texte, et rien que du texte.

Un code source, un export comptable, un fil de messages, un contrat, un tableur exporté : tout ce qui est du texte passe, et c’est l’essentiel de ce sur quoi vous travaillez. Les images et les documents scannés sont hors du périmètre de cette version.

Une mémoire qui retrouve des mots.

Elle cherche en plein texte et classe par pertinence, ce qui la rend exacte et prévisible : vous savez toujours pourquoi un souvenir remonte. Elle ne rapproche pas deux formulations différentes de la même idée, il faut donc lui parler avec les mots qu’elle a vus.

Une installation, une personne.

Apollia tourne sous votre compte, avec vos droits, et travaille pour vous seul. Il n’y a pas d’instance partagée entre plusieurs utilisateurs, donc pas de comptes à administrer ni de rôles à distribuer avant de commencer.

Ce qui est écrit est écrit.

Il n’existe pas de bouton pour revenir en arrière sur une action déjà faite. Ce qui vous protège se trouve avant et après : l’accord demandé au moment de l’action, et le journal qui garde la trace de chaque geste.

Le reste, y compris les réponses qui n’arrangent pas le projet, tient sur une page à part, écrite pour être lue avant l’installation plutôt qu’après. Les 23 questions, et nos réponses

La lecture s’arrête ici. Le reste se constate.

Vous en saurez plus en une soirée sur vos propres fichiers qu’en relisant cette page. La page de téléchargement vous dit ce que vous allez rencontrer avant que vous le rencontriez : l’avertissement de sécurité de votre système au premier lancement, les prérequis de votre machine, et le modèle qu’il faudra choisir.

0.2.0-preview · macOS, Windows, Linux · Apache 2.0 ou MIT