What is Re in Act?

Re in Act is about making action stronger by keeping reason inside it.

In traditional ReAct (Reason → Act → Observe → Repeat), small action problems keep bouncing back to the outer loop. That creates extra round trips, noisy context, and brittle control.

Re in Act introduces a Reason-able Action Space (RAS) so those local problems can be handled where they appear. Top-level reasoning defines the RAS and its constraints; the action phase uses that space to inspect feedback, make bounded judgments, and keep moving.

The result is simpler action: fewer outer-loop turns, less context bloat, and a larger effective action space.

The Cerebellum Metaphor

Think about walking. The conscious brain decides to move, but it does not micromanage every correction. Adjustment happens closer to the body and closer to feedback, saving cognitive load and preserving better feedback.

Top-level reasoning should define the work and its constraints. The action layer should handle local disturbances inside that bounded action space instead of escalating every small issue back to the outer loop.

This metaphor matters for two reasons:

1. Bounded action: the RAS works inside a defined task package rather than inventing a new top-level objective.
2. Local adaptation: the RAS can use nearby observations, intermediate data, and runtime control flow to adjust while action is already underway.

The deeper theory points in the same direction:

• Ashby's Law (Requisite Variety): only variety can absorb variety. ReAct's fixed action layer often cannot express enough differentiated responses to handle local disturbances well. The RAS expands that local controller variety.
• Good Regulator Theorem: a successful regulator needs access to a model of the system it regulates. In Re in Act, the RAS supplies task-relevant local structure, so the agent does not need to rebuild that structure from scratch on every outer-loop turn.

If you want the deeper version of this argument, see Control-Theoretic View.

At a Glance

Key Concepts

Reason-able Action Space (RAS)

The RAS is the action context that top-level reasoning defines for an orchestrated action phase. It contains:

• reason(prompt, example_output) — a local judgment step whose prompt carries the goal, local observations, relevant context, and governing constraints or rules
• deterministic control flow for retries, branching, and intermediate-data handling

The RAS is not just a place to run tools. It is the part of the system that top-level reasoning still structures while action inspects local observations, makes bounded judgments, and keeps moving without turning every small issue into another outer-loop turn.

It may also provide:

• act(name, args) — calls an external tool and returns its result (optional — you may use your own action executor)

A Typical Bash RAS Example

Here is a minimal example of reason in action as progressive discovery: the agent first asks act --manual for the available tool surface, lets reason pick only the relevant tool names, then asks act --manual [name] for the detailed definitions of just those tools.

act --manual | \
	reason \
		--prompt "Goal: find the tools needed to collect the most relevant API and documentation context for this task." \
		--prompt - \
		--prompt "Constraints: return only a JSON array of tool names. Prefer the smallest sufficient set." \
		--structure '["tool_name"]' | \
	jq -r '.data[]' | while read -r name; do
		act --manual "$name"
	done

This is the core Re in Act move in Bash form: reason stays inside the action, using live local data to narrow the next step before more external work happens.

Two Runtime Flavors

• Bash RAS — Unix pipelines composing reason and act as CLI commands
• Code RAS — Python or TypeScript scripts with native async/await control flow

See Concepts → for annotated examples of both.

What Re in Act Is Not

• Not a subagent pattern — Re in Act does not create another reasoning actor. It creates one orchestrated action space for the same agent.
• Not incompatible with subagents — a subagent can still use Re in Act internally. The subagent remains the reasoning unit; the RAS is the action space it uses to carry work out.
• Not an independent reasoning actor — the RAS is an action context that top-level reasoning defines and orchestrates. It is not a peer planner.
• Not open-ended local reasoning — inside the RAS, reason() is a schema-bounded local judgment step, not a second free-form agent loop.
• Not step-by-step exposure to the outer loop — intermediate action state can stay inside the RAS until there is a denoised result worth returning.

If you want the full architectural comparison, see Subagent vs Re in Act →.

Next Steps

• Try Re in Act → — a Bash quickstart around reason, act, and one-agent
• Concepts → — deeper walkthrough of runtime flavors and interfaces
• Control-Theoretic View → — the deeper design argument behind the architecture
• Specification → — the full formal draft
• one-agent → — the reference implementation