Re in Act

Try Re in Act

Two ways to try Re in Act: a fast proxy launch path and a direct Bash RAS setup with reason and act.

Try Re in Act

This page gives a small Bash RAS you can run first.

There are now two practical ways to try Re in Act:

  1. Fast proxy experience — launch a tool through @one-agent/ria-proxy and immediately experience Re in Act mode.
  2. Direct Bash RAS setup — install reason and act, then build the action space yourself.

The relevant packages are:

  • @one-agent/ria-proxy
  • @one-agent/reason
  • @one-agent/act
  • npx skills add ria-spec/one-agent

1. Fast Proxy Experience

If you want the quickest path to trying Re in Act mode, launch through the proxy:

npx @one-agent/ria-proxy launch opencode

This path is for immediate use: the proxy launches the target tool in Re in Act mode without requiring you to manually wire the action surface first.

2. Direct Bash RAS Setup

If you want the interfaces directly in your shell, install the runtime surface:

npm install -g @one-agent/reason @one-agent/act
npx skills add ria-spec/one-agent

The goal is simple:

  • reason gives Bash a bounded local judgment step
  • act gives Bash a clean action interface
  • the one-agent skill wires that into a usable local workflow

3. Configure reason

reason --help

reason needs a model configuration before it can run. The exact provider settings are part of the CLI surface; reason --help is the entry point for that configuration.

4. Configure act

act --help

act needs action backends. In practice that means configuring mcpServers or whatever action surface your runtime exposes.

If you only want to try reason first, you can still combine it with ordinary Bash commands before wiring act into MCP.

5. Four Small Examples

Instead of one larger workflow, here are four smaller Bash examples. Each shows one advantage emphasized in the spec.

5.1 Fewer Round Trips

Make one local decision, then take the next step immediately inside the same action phase.

decision="$(act read_file '{"path":"build.log"}' | \
  reason \
    --prompt "Goal: decide the next local step for this failed build." \
    --prompt - \
    --prompt "Constraints and rules: return only action, reason, and retry_cmd." \
    --structure '{"action":"continue","reason":"","retry_cmd":""}')"

retry_cmd="$(printf '%s' "$decision" | jq -r '.data.retry_cmd')"
[ -n "$retry_cmd" ] && act bash "{\"cmd\":\"$retry_cmd\"}"

Without a RAS, this usually becomes another outer-loop turn. Here the local decision and the local follow-up stay together.

5.2 Clean Context Window

Keep the noisy log local and return only the bounded result that matters.

act read_file '{"path":"build.log"}' | \
  reason \
    --prompt "Goal: extract only the deployment-blocking issue from this log." \
    --prompt - \
    --prompt "Constraints and rules: ignore ANSI color, progress output, and repeated lines; return only issue and next_step." \
    --structure '{"issue":"","next_step":""}' | \
  jq .

The outer loop does not need the whole log. It only needs the denoised result.

5.3 Deterministic Control Flow

Let shell handle the loop deterministically, while reason() only makes the bounded judgment inside each step.

printf '%s\n' docs/docs/getting-started/intro.mdx docs/docs/getting-started/concepts.mdx | \
while read -r path; do
  act read_file "{\"path\":\"$path\"}" | \
    reason \
      --prompt "Goal: decide whether this page discusses subagents." \
      --prompt - \
      --prompt "Constraints and rules: return only path and mentioned true/false." \
      --structure '{"path":"","mentioned":false}'
done

The loop is not left to the model. The runtime controls the traversal; reason() only interprets each file.

5.4 Higher Effective Controller Variety

Use local discovery before action, instead of deciding everything upfront.

act --manual | \
  reason \
    --prompt "Goal: find the tools needed to collect the most relevant API and documentation context for this task." \
    --prompt - \
    --prompt "Constraints and rules: 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 programmable part of the RAS: it can inspect, filter, branch, and adapt locally instead of using one fixed outer-loop response pattern.

6. Where To Go Next