ReAct (Autonomous Agent)

Transcript only

Implement the ReAct (Autonomous Agent) pattern in this codebase, using the LLM client and language we already use.

## Goal

Answer a question that needs several lookups by letting one model alternate Thought, Action and Observation, choosing each next action from the last result, until it writes a Final Answer.

## How it works

1. Fill the ReAct system prompt with the tool descriptions and the question; this is the start of the transcript.
2. Call the model with the transcript, stopping generation at the text 'Observation:' so it cannot write one itself.
3. Parse the reply. If it contains 'Final Answer:', return the text after it. Otherwise read its Action line as tool_name[input].
4. Run the named tool with that input and append 'Observation: ' plus the result to the transcript. If the tool fails or times out, append the error message as the Observation.
5. If the Action line does not parse or names an unknown tool, append an Observation saying so and listing the valid tool names.
6. Call the model again with the longer transcript and repeat.

## Prompts

### ReAct system prompt

```markdown
Answer the question by interleaving Thought, Action and Observation.

Available actions:
{{tool_descriptions}}

Use exactly this format:
Thought: what you know and what you need next
Action: tool_name[input]
Observation: (written by the system, never by you)

When you can answer, write:
Thought: I now have enough information.
Final Answer: your answer

Rules:
- One action per turn. Wait for the observation.
- If an action fails, say why in your next Thought and try a different approach.
- Do not answer from memory when a tool can verify the fact.

Question: {{question}}
```

## Stop rule

Stop when the model writes a Final Answer, or after 10 turns. At the cap, append 'You must answer now.' and make one last call; return that answer flagged as having hit the turn limit.

## Requirements

- Make the turn cap (default 10) and the per-tool timeout (default 10 seconds) parameters.
- Truncate each Observation to a set length (default 2,000 characters) so one large result cannot fill the context.
- End the loop early with a 'stuck' status if the same Action with the same input repeats 3 times in a row.
- Log the full transcript, plus each tool's latency and the token counts per turn.
- Add a test with a stub LLM scripted to emit search[Eiffel Tower], search[Golden Gate], calculator[1937-1889] and then 'Final Answer: 48'; assert four model calls, three tool calls in that order, and the answer '48'.

To-do notes

Implement the ReAct (Autonomous Agent) pattern (To-do notes variant) in this codebase, using the LLM client and language we already use.

## Goal

Run a long ReAct loop that keeps its plan and findings in an external notes file, so its progress survives when old turns drop out of the context.

## How it works

1. Create an empty notes file for the run and give the agent one extra action, update_notes[text], which replaces the file's contents.
2. Before every model call, put the current notes at the top of the prompt, above the most recent turns.
3. Call the model with the ReAct system prompt, the notes and the recent transcript, and parse its Thought and Action as in plain ReAct.
4. Run the action. For update_notes, save the text and return 'notes saved' as the Observation; on a tool error, return the error text as the Observation.
5. Keep only the last 8 turns of the transcript in the prompt; the notes carry everything older.
6. When the model writes a Final Answer, return it together with the final notes.

## Prompts

### ReAct system prompt

```markdown
Answer the question by interleaving Thought, Action and Observation.

Available actions:
{{tool_descriptions}}

Use exactly this format:
Thought: what you know and what you need next
Action: tool_name[input]
Observation: (written by the system, never by you)

When you can answer, write:
Thought: I now have enough information.
Final Answer: your answer

Rules:
- One action per turn. Wait for the observation.
- If an action fails, say why in your next Thought and try a different approach.
- Do not answer from memory when a tool can verify the fact.

Question: {{question}}
```

## Stop rule

Stop on a Final Answer, or after 40 turns. At the cap, return the notes with a status saying the run stopped early, so a new run can resume from them.

## Requirements

- Make the turn cap (default 40), the kept-turn window (default 8) and the notes size limit (default 4,000 characters) parameters.
- Reject an update_notes call over the size limit with an Observation asking for a shorter version, and keep the old notes.
- Store the notes outside the process, in a file or a database row, so a crashed run can resume from them.
- Log every notes revision with its turn number.
- Add a test with a stub LLM that calls update_notes['[x] A [ ] B'] on turn 1; with the window set to 8, assert the turn-10 prompt contains '[x] A [ ] B' but not turn 1's transcript.

Context compaction

Implement the ReAct (Autonomous Agent) pattern (Context compaction variant) in this codebase, using the LLM client and language we already use.

## Goal

Keep a ReAct loop running past the context limit by summarizing its history whenever the transcript nears the limit, then continuing from the summary in a fresh window.

## How it works

1. Run the ReAct loop as usual with the ReAct system prompt: call the model, run its Action, append the Observation.
2. Before each model call, count the transcript's tokens. Below the threshold, carry on as normal.
3. At or above the threshold, send the transcript, minus the last 3 turns, to a summarizer call that must keep the goal, decisions made, facts found with their sources, and the next step.
4. Start a new transcript: the original question, the summary under a 'Progress so far' heading, then the 3 kept turns verbatim.
5. Continue the loop from the new transcript, and return the Final Answer when the model writes one.

## Prompts

### ReAct system prompt

```markdown
Answer the question by interleaving Thought, Action and Observation.

Available actions:
{{tool_descriptions}}

Use exactly this format:
Thought: what you know and what you need next
Action: tool_name[input]
Observation: (written by the system, never by you)

When you can answer, write:
Thought: I now have enough information.
Final Answer: your answer

Rules:
- One action per turn. Wait for the observation.
- If an action fails, say why in your next Thought and try a different approach.
- Do not answer from memory when a tool can verify the fact.

Question: {{question}}
```

## Stop rule

Stop on a Final Answer, or after 60 turns in total. If a fresh window is still over the threshold after compaction, stop with a 'context exhausted' status and return the summary.

## Requirements

- Make the threshold a fraction of the model's context window (default 0.75) and the kept-turn count (default 3) parameters.
- If the summarizer call fails, retry it once; if it fails again, drop the oldest half of the turns instead and log that no summary was made.
- Keep the original question verbatim in every window; never summarize it.
- Log each compaction with the token counts before and after.
- Add a test with a stub token counter that reports 160k of 200k tokens on turn 5; assert the summarizer is called exactly once and the turn-6 prompt contains the stub summary and not turn 1's Observation.