# `Jido.AI.TRMAgent`
[🔗](https://github.com/agentjido/jido_ai/blob/v2.4.0/lib/jido_ai/agents/strategies/trm_agent.ex#L3)

Base macro for TRM (Tiny-Recursive-Model) agents.

Wraps `use Jido.Agent` with `Jido.AI.Reasoning.TRM.Strategy` wired in,
plus standard state fields and helper functions.

## Usage

    defmodule MyApp.ReasoningAgent do
      use Jido.AI.TRMAgent,
        name: "reasoning_agent",
        description: "Agent that improves answers through recursive reasoning",
        max_supervision_steps: 10,
        act_threshold: 0.95
    end

## Options

- `:name` (required) - Agent name
- `:description` - Agent description (default: "TRM agent #{name}")
- `:model` - Model alias or direct model spec (default: :fast, resolved via Jido.AI.resolve_model/1)
- `:max_supervision_steps` - Maximum supervision iterations before termination (default: 5)
- `:act_threshold` - Confidence threshold for early stopping (default: 0.9)
- `:skills` - Additional skills to attach to the agent (TaskSupervisorSkill is auto-included)

## Generated Functions

- `reason/2,3` - Async: sends prompt, returns `{:ok, %Request{}}` for later awaiting
- `await/1,2` - Awaits a specific request's completion
- `reason_sync/2,3` - Sync convenience: sends prompt and waits for result
- `strategy_opts/0` - Returns the strategy options (for CLI access)
- `on_before_cmd/2` - Captures request in state before processing
- `on_after_cmd/3` - Updates request result when done

## Request Tracking

Each `reason/2` call returns a `Request` struct that can be awaited:

    {:ok, request} = MyAgent.reason(pid, "What is the best approach to solve X?")
    {:ok, result} = MyAgent.await(request, timeout: 30_000)

Or use the synchronous convenience wrapper:

    {:ok, result} = MyAgent.reason_sync(pid, "What is the best approach to solve X?")

## State Fields

The agent state includes:

- `:model` - The LLM model being used
- `:requests` - Map of request_id => request state (for concurrent tracking)
- `:last_request_id` - ID of the most recent request
- `:last_prompt` - The most recent prompt (backward compat)
- `:last_result` - The final result from the last completed reasoning (backward compat)
- `:completed` - Boolean indicating if the last reasoning is complete (backward compat)

## Task Supervisor

Each agent instance gets its own Task.Supervisor automatically started via the
`Jido.AI.Plugins.TaskSupervisor`. This supervisor is used for:
- LLM streaming operations
- Other async operations within the agent's lifecycle

## Example

    {:ok, pid} = Jido.AgentServer.start(agent: MyApp.ReasoningAgent)

    # Async pattern (preferred for concurrent requests)
    {:ok, request} = MyApp.ReasoningAgent.reason(pid, "What is the best approach to solve X?")
    {:ok, result} = MyApp.ReasoningAgent.await(request)

    # Sync pattern (convenience for simple cases)
    {:ok, result} = MyApp.ReasoningAgent.reason_sync(pid, "What is the best approach to solve X?")

## TRM Workflow

TRM uses recursive reasoning to iteratively improve answers:
1. **Reasoning**: Generate insights about the current answer
2. **Supervision**: Evaluate the answer and provide feedback with a score
3. **Improvement**: Apply feedback to generate a better answer
4. Repeat until confidence threshold is met or max steps reached

---

*Consult [api-reference.md](api-reference.md) for complete listing*