How Much To Run AI
Open weights

Terminal-RSI-27B: Local Setup, Memory and Agent Costs

Terminal-RSI-27B is an Apache-2.0 checkpoint trained from Qwen3.8-27B for terminal-agent tasks. It generates actions and explanations; an external agent loop must execute commands, return observations and verify completion. Start with a bounded repository task, choose a supported weight format and budget the whole session, including failed attempts and tool time.

Content reviewed:

Read the Terminal-RSI-27B model card ↗
Terminal-RSI-27B download sizes from the 55.56 GB BF16 checkpoint to GGUF conversions at 17.44–23.86 GB, Terminal-Bench scores from 86.52% on 2.1 to 16.95% on 3.0 under the documented Mean@3 harness, and a two-hour session budget of about $0.08 in electricity.
Original diagram of file sizes and evaluation settings; GGUF sizes are downloads, not measured memory, and the model proposes while an external loop executes.

Use this model

See access details in the guide below.

Use cases

  • Repair a small repository bug and verify the patch with an external test.
  • Study long-horizon terminal tasks with an explicit tool protocol and verifier.
  • Compare the trained checkpoint with Qwen3.8-27B using the same agent harness.

What changes from Qwen3.8-27B?

The release is a terminal-agent checkpoint with 27.78 billion parameters including visual components. The exact download namespace is Teriminal-RSI/Terminal-RSI-27B; retain that spelling in commands. It uses BF16 weights and a configuration with 262,144-token context capacity. Actual supported context and memory depend on the runtime and workload.

The research alternates rewriting verified trajectories with further policy training. That is how the released checkpoint was trained. The useful comparison is whether the resulting policy completes your tasks with fewer errors or retries.

Choose BF16 or a community GGUF

The original BF16 checkpoint files occupy about 55.56 GB, or 51.75 GiB, before activations, runtime buffers and conversation state. Download the complete repository: its index requires all 13 Safetensors shards, including the two files whose names begin model-missing-from-origin. Those are required model parts.

Bartowski also distributes GGUF conversions generated with llama.cpp b11845. Its listed Q4_K_M download is 17.44 GB, Q5_K_M is 20.92 GB and Q6_K is 23.86 GB. These are conversion file sizes, not measured RAM or VRAM requirements. Leave room for the selected context and the operating system; choose a runtime that supports this architecture and any visual components you need.

A smaller quantization saves memory but can change exact command syntax and tool behavior. Test a known task through your actual agent client before choosing a quantization for a longer unattended job. The GGUF conversion does not come with an independently established terminal-task success rate.

Generate a first response, then add execution

The model card provides a Transformers example using Qwen3_5ForConditionalGeneration. Install a Transformers version supporting that class, PyTorch and Accelerate. The packaging notes report configuration loading with Transformers 5.17.0; full model loading and GPU inference were not validated as part of that packaging check. Use the linked card for its current dependency recipe.

The following text-only example asks for an investigation plan. A successful run returns generated text. To perform the task, connect the model to a client that validates its actions, executes them in an isolated working directory, returns tool observations and runs an independent completion check.

First Transformers text response
import torch
from transformers import AutoTokenizer, Qwen3_5ForConditionalGeneration

model_id = "Teriminal-RSI/Terminal-RSI-27B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = Qwen3_5ForConditionalGeneration.from_pretrained(
    model_id, dtype=torch.bfloat16, device_map="auto"
)
messages = [
    {"role": "system", "content": "Explain your next action; do not claim to have executed commands."},
    {"role": "user", "content": "How would you investigate a missing dependency in a small Python repository?"},
]
prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True, enable_thinking=False
)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
with torch.inference_mode():
    output = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(tokenizer.decode(output[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True))

Read terminal benchmarks with their harness

The paper reports 86.52% on Terminal-Bench 2.1, 19.84% on Terminal-Bench 4.0, 16.95% on Terminal-Bench 3.0 and 79.00% on Terminal-Bench Hard. These suites differ; selecting the largest score would hide much of the task difficulty.

The documented evaluation uses structured JSON actions, thinking disabled, temperature 0.60, top-p 0.95, up to 8,192 generated tokens per turn and 96,000 input tokens per call. History is summarized at 32,000 accumulated tokens, with benchmark-specific time and termination limits. A different client, tool schema or verifier can change the result.

For a local comparison, hold the repository, prompts, tools, timeout and success tests constant. Count failures to call tools correctly alongside code errors, and retain the complete transcript. Compare against the original Qwen checkpoint before attributing any difference to the recursive training method.

Use the research harness for an execution comparison

The official codebase builds on slime, with Megatron training, SGLang model serving and Ray orchestration. Its examples/terminal_rsi/run_eval.sh evaluates a Harbor task pool, and its reported inference uses a Harbor agent connected to the model server. The documented setup uses CUDA dependencies and Daytona sandboxes. Budget those execution resources separately from downloading weights or opening a chat client.

The published Terminal-Bench scores use Mean@3. The weights, community GGUF files and loading examples do not establish the same task success rate on a consumer machine. Keep the tool protocol, sandbox and verifier with any reproduction result.

Budget the complete local agent session

The downloadable checkpoint has no published per-token charge. Your costs include hardware time, power, storage and the commands the agent runs. A slow failing task can cost more than a short successful run even when both use the same model.

For a planning example, a computer averaging 200 watts for two hours uses 0.4 kWh. At an assumed $0.20/kWh, electricity is $0.08. Add hardware allocation, setup time and any paid tools separately. For a rented server, multiply its actual hourly price by all reserved hours, including installation and unsuccessful attempts, then divide by verified completed tasks.

Begin with a disposable copy of a repository and a fixed test command. Keep production credentials out of the execution environment. Review the first patch and transcript before increasing the task scope or budget.

Before you use it

  • Agent results depend on the tool protocol, time limits and external verifier; test a conversion through the client you intend to use.

How to get started

Generate a short response first, then connect an isolated repository and independent tests. Keep the model revision, runtime, complete transcript and session cost with the accepted result.

Sources

Sources (4)

Calculators