API Python

from agentl import (
    Analyzer,
    Host,
    MockLLM,
    Runtime,
    parse_file,
    verify,
)

from agentl import Analyzer, parse_file, parse_source

program = parse_file("agent.agent")
agent = program.agents[0]
diagnostics = Analyzer(agent).run()

inline = parse_source("AGENT EMPTY { GOAL done { ACHIEVE ok == yes } }")

from agentl import Host, MockLLM, Runtime, Symbol, parse_file

agent = parse_file("service_guard.agent").agents[0]
host = Host()

host.sensors["service.status"] = lambda: Symbol("healthy")

runtime = Runtime(agent, host, MockLLM())
runtime.run(max_ticks=4)
trace = runtime.trace

from agentl import parse_file, verify

agent = parse_file("agent.agent").agents[0]
report = verify(agent)

for theorem in report.theorems:
    print(theorem)

from agentl import ActionRequest, PolicyEngine

from agentl import Inference, Planner, infer, reachable_range

from agentl import MockLLM, Society

society = Society(
    program.agents,
    hosts={"analyst": analyst_host, "responder": responder_host},
    llms={"analyst": MockLLM(), "responder": MockLLM()},
)
society.run(max_ticks=6)

from agentl.durable import DurableRun, FileStore, SQLiteStore, NOT_EXECUTED

run = DurableRun(agent, host, llm, store=FileStore("runs/agent"))
runtime = run.run(max_ticks=8)            # neuve, ou reprise
run.resumed, run.status, run.journal.resolutions
journal = run.export()                    # journal de rejeu standard

from agentl.kernel import current_action, PermitError, TCB_FILES
from agentl.kernel.testing import dispatch
from agentl.kernel.provenance import untrusted

ctx = current_action()                    # dans un outil : action_id, idempotency_key, attempt
dispatch(host, "transfer", {"amount": 100, "to": "acct-1"})   # tester sous permis
host.sensors["mail.subject"] = lambda: untrusted(read_subject())

from agentl.aio import AsyncHost, AsyncRuntime, AsyncSociety, Limits

rt = AsyncRuntime(agent, AsyncHost(), llm, limits=Limits(tool_timeout=10))
await rt.run(max_ticks=8)

society = AsyncSociety(program.agents, hosts={...}, limits=Limits(inbox_capacity=50))
await society.run(max_ticks=6)

from agentl import (
    Journal,
    RecordingHost,
    RecordingLLM,
    ReplayHost,
    ReplayLLM,
    verify_trace,
)