Agent

Un agent porte une responsabilité explicite. Contrairement à une skill, qui décrit une composition bornée et réutilisable, l’agent est l’unité qui choisit, dans un périmètre déclaré, quelle capacité exécuter pour cette exécution, et qui peut être tenue responsable de ce choix.

Forme

source.tb

agent AgentName
    takes request as RequestType
    gives ResultType
    responsibility "Fulfill the declared AgentName responsibility using only authorized capabilities."
    uses SomeSkill
    callable_by strategy StrategyName

uses déclare ce que l’agent peut exécuter : function, tool, skill, autre agent ou strategy. callable_by déclare les stratégies ou agents autorisés à l’invoquer.

takes et gives déclarent, quand ils sont présents, l’interface directe de l’agent. Elle n’est jamais déduite de uses : les capacités restent des moyens internes que l’agent peut choisir, pas son point d’entrée implicite.

Interface d'appel typée

agent_type.tb

module examples.agent_type

type ReviewRequest
    summary is Text

type ReviewResult
    verdict is Text

tool InspectRequest
    description "Inspect one request and return a review result."
    takes request as ReviewRequest
    gives ReviewResult

agent Reviewer
    takes request as ReviewRequest
    gives ReviewResult
    responsibility "Review the explicit request and return one typed final result."
    uses InspectRequest
    callable_by strategy RunReview

strategy RunReview
    takes request as ReviewRequest
    gives ReviewResult
    uses Reviewer
    do
        Reviewer
            with request as request
            into review
        give review

Chaque entrée est liée par with; seule la sortie finale validée contre gives est placée dans into. Une réponse directe du provider est soumise au même contrôle de type. Les résultats de capacités et les observations de la boucle restent intermédiaires et ne deviennent pas implicitement la sortie.

Un agent sans takes ni gives accepte l'appel simple, sans with ni into. Pour un agent importé avec une interface explicite, le compilateur résout les signatures depuis les sources des modules du projet. Les types conservent leur identité de module et le caller doit toujours être autorisé. Voir Imports multi-modules.

Cas simple

agent_simple.tb

module examples.agent_simple

type DatasetRequest
    query is Text

type DatasetBrief
    summary is Text

tool SearchDatasets
    takes request as DatasetRequest
    gives DatasetBrief
    requires network

skill BuildDatasetBrief
    takes request as DatasetRequest
    gives DatasetBrief
    uses SearchDatasets
    do
        SearchDatasets
            with request as request
            into result
        give result

agent Researcher
    responsibility "Fulfill the declared Researcher responsibility using only authorized capabilities."
    uses BuildDatasetBrief
    callable_by strategy RunDatasetResearch

strategy RunDatasetResearch
    uses Researcher
    do
        Researcher

Avec une seule capacité déclarée dans uses, le runtime peut sélectionner BuildDatasetBrief automatiquement, sans décision explicite ni provider configuré.

Cas avancé

agent_advanced.tb

module examples.agent_advanced

type DatasetRequest
    query is Text

type DatasetBrief
    summary is Text

tool SearchDatasets
    takes request as DatasetRequest
    gives DatasetBrief
    requires network

skill BuildDatasetBrief
    takes request as DatasetRequest
    gives DatasetBrief
    uses SearchDatasets
    do
        SearchDatasets
            with request as request
            into result
        give result

skill ReviewBrief
    takes brief as DatasetBrief
    gives DatasetBrief
    do
        human.approve
            with context as brief
            into approved

        give brief

agent Researcher
    responsibility "Fulfill the declared Researcher responsibility using only authorized capabilities."
    uses BuildDatasetBrief
    uses ReviewBrief
    callable_by strategy RunDatasetResearch

strategy RunDatasetResearch
    uses Researcher
    do
        Researcher

Dès qu’un agent déclare plusieurs capacités dans uses, une décision structurée devient nécessaire : le runtime présente le résumé des capacités autorisées à un provider de décision configuré, vérifie que la cible choisie appartient bien à uses, mappe les arguments fournis sur sa signature, puis trace la décision ou le refus. Le détail de cette boucle est couvert par Décision agentique gouvernée.

Skill vs agent

• Une skill décrit comment composer des étapes : elle ne décide de rien, elle exécute une séquence bornée.
• Un agent porte qui est responsable du choix : il sélectionne, parmi ce que uses autorise, la capacité à exécuter pour cette exécution.

Un agent peut uses une skill (le cas le plus courant), un tool, une function, un autre agent ou une strategy. Dans tous les cas, uses reste la seule source de périmètre : l’agent ne peut pas appeler ce qui n’y figure pas.

Ce que l’agent porte

Sans agent, le choix entre plusieurs capacités serait soit codé en dur dans une skill (donc plus une vraie décision), soit délégué à un appel de modèle libre, hors du contrôle du runtime.

Avec agent, ce choix devient un point explicite du graphe : déclaré, borné par uses, autorisé par callable_by, et tracé par le runtime, qu’une décision soit automatique (capacité unique) ou structurée via un provider (capacités multiples).

Portée technique

• Un agent ne peut exécuter que ce qui est déclaré dans uses.
• callable_by accepte des callers strategy ou agent, y compris qualifiés par module.
• Les mémoires et secrets accessibles exigent des scopes explicites ; une délégation ne transfère pas les droits du spécialiste à son parent.
• Une stratégie peut distribuer une liste d'entrées sur un agent typé avec parallel. Chaque invocation garde ses données et partage les budgets du run.
• Un agent peut aussi sélectionner une stratégie autorisée contenant un groupe parallèle. Sa propre boucle de décision reste séquentielle.
• La coordination passe par des arguments et résultats typés ; elle ne crée ni conversation libre, ni découverte de capacités hors uses.
• Une capacité autorisée reste réutilisable tant que les budgets le permettent.
• Voir Autonomie bornée et Décision agentique gouvernée pour le détail du contrôle runtime.