stalwart-agents

Declare an agent in one file: its tools, its rules and its users. Then check it and run it. You don't need to learn an agent framework for any of this.

$ pip install stalwart-agents                # everything: the agents, the client, the gateway, the runtime
$ pip install "stalwart-agents[anthropic]"   # with a model provider: anthropic, openai, google, mistral or ollama
$ pip install "stalwart-agents[all]"         # with every provider

The local runtime ships for Linux (x86-64 and arm64), macOS on Apple silicon and Windows (x86-64). Anywhere else -- an Intel Mac, Alpine, Windows on ARM -- the same command installs the package without it, and the Stalwart service answers its plans and checks.

# agent.yaml
agents:
  desk:
    model: "anthropic:claude-sonnet-5-5"   # your provider and key, from your environment
    tools: [get_order, charge_card, refund_card, read_inbox]
    hands_off_to: [billing]
  billing:
    privilege: high
    tools: [issue_refund]
tools:
  - python: shop.tools                     # plain functions, schemas from their type hints
  - mcp: https://tools.internal/mcp        # an MCP server's tools/list
    receipts: true                         # behind a gateway that admits a call on the agent's own check
  - openapi: ./crm.yaml                    # each HTTP operation a tool
  - name: refund_card
    writes: true
rulebook: ./policy.co                      # Colang 1.0 or 2.x
runs: atomic                               # a failed run is undone
storage: sqlite:///runs.db                 # where runs are kept; postgres://... for several workers

Or in Python, with the same meaning:

from stalwart_agents import Agent, tool

@tool(writes=True, undo="refund_card")
def charge_card(order_id: str, amount: Decimal) -> dict: ...

desk = Agent("desk", tools=[get_order, charge_card, refund_card], rulebook="policy.co",
             model="anthropic:claude-sonnet-5-5")
reply = desk.chat("refund order 4411", user="u-17")
if reply.waiting:                          # a write waits for the person
    reply = desk.confirm("u-17", "approve")

Before a turn runs, the agents' graph is proved once (verify=False runs it unproved). A turn nothing reads is asked to be said again once; then on_unread decides: refuse, model, or ask, where the person says whether the model may have it (desk.confirm(user, "approve") or "decline").

A person's thumb on a reply is feedback the hosted miner learns your users' words from:

reply = desk.chat("what is in order 4411?", user="u-17")
desk.thumbs(reply, up=False)        # one record: the turn's words, the tool, the router's verdict and rule

The record holds the rated turn's words and the router's reading of them -- the tool, its verdict and deciding rule, the tools the agent could reach -- and nothing else: no reply text, argument value, tool result or earlier turn. A turn the router could not read and the model answered records the verdict unread and the tool the model called. The same thumb twice is one record. Some thumbs are refused with ThumbRefused, saying what to thumb instead: a turn of several instructions is thumbed one step at a time (step=0, step=1, ...), and the reply after a confirmation is thumbed on the turn that named the tool. stalwart serve takes the same thumb at POST /threads/{id}/feedback, from the session that was shown the reply only.

An MCP server's tools are called in an MCP session per user: the user a turn names, or its thread under stalwart serve. What a server keeps for one session never reaches another user. desk.close() ends every session; stalwart serve ends them when it stops.

A tool's words are plain: writes, undo, irreversible, retry_safe, reads_outside, sends_out, after, not_after, at_most, and the words the bug hunter's OWASP rules read (argument_kinds, sandboxed, confidential, ...). A model is provider:model, resolved with your own key from your environment. A missing key is named before anything is sent. A model can also be a plain function that takes the conversation and returns the reply.

Nothing on stalwart_agents' own surface names LangChain or LangGraph: no name, signature, error or message. A test holds the package to that. stalwart_agents.langchain is there for a team already on LangGraph. desk.graph() is the one way to reach the graph that runs underneath, for a team that wants to extend it.

The same install carries the rest, each documented on its own page: