# Tura

> Tura is a local, open-source coding agent that uses macro CLI commands and backward reasoning to complete long-horizon development tasks with significantly fewer model turns and tokens than conventional tool-calling agents.

Tura is a local, open-source coding agent built for developers who want evidence-backed performance rather than vague skill claims. It is written in Rust, licensed under AGPL-3.0, and installable via npm or source checkout on Windows, macOS, and Linux. The project publishes its benchmark artifacts publicly so results can be independently reviewed.

## What It Is

Tura is a harness-based coding agent that replaces the conventional tool-calling loop with a macro command architecture. Instead of exposing dozens of small tools to the language model — each requiring a separate LLM turn — Tura exposes a single `command_run` macro that lets the agent build a multi-step execution tree and run patching, compiling, testing, and linting in one model round. The project positions itself as an agent harness framework, not a plugin or extension, and explicitly avoids skills, context-compaction turns, and tool-calling overhead.

## Benchmark Evidence

The project publishes a community benchmark covering 348 long-horizon sessions across DeepSWE, rewrite, and design task categories. The primary comparison holds the model and reasoning label fixed — Tura Balanced High, Tura Direct High, and the official Codex CLI High configuration — all running GPT-5.6 SOL at High reasoning effort on the same 20 DeepSWE task IDs across 60 sessions each.

According to the published benchmark artifacts:

- **Tura Balanced** reached an 80.0% verifier success rate on DeepSWE, compared with 60.0% for Codex CLI High — a 20 percentage point difference — while using 49.6% fewer tokens and 66.8% fewer model rounds.
- **Tura Direct** prioritizes cost reduction: 83.5% fewer aggregate tokens and 84.0% fewer model rounds than Codex CLI High, with a 65.0% verifier success rate versus 60.0%.
- On the rewrite benchmark, Tura used up to 83.1% fewer turns.
- The published cohort averages 43.5 agent turns per session across 15,138 total agent turns.

The project notes that these results are system-level associations, not causal estimates for any individual feature, and that broader provider coverage (Anthropic/Claude, Google/Gemini, local providers) and cross-OS measurements remain on the documented roadmap.

## Three Core Mechanisms

Tura's architecture centers on three systems:

- **Macro CLI Command Run**: The `command_run` tool accepts a structured JSON execution tree, allowing inspect, patch, build, test, and lint steps to execute in a single LLM turn rather than five separate ones.
- **Backward Reasoning**: Rather than reasoning forward from current state to goal, Tura guides the LLM to estimate the pre-goal state first, then reason backward. In coding tasks this means reconstructing the failure state and identifying the root cause before writing any code.
- **Runtime Context and Prompt Manager**: Context is treated as part of the runtime state machine. Task-specific manuals and CLI commands load through a recursive task tree; irrelevant context can be removed or compacted from the CLI. The checkpoint retains code locations, patches, tests, and task status rather than only a loose summary. In the published benchmark sessions, Tura resumed execution an average of 2.6 rounds after compaction.

## Setup Path

Tura runs locally and does not bundle provider credentials. Users configure an LLM provider on first launch. Installation options:

- **npm**: `npm install tura-ai` (Mac/Linux) or `npm install -g tura-ai` (Windows)
- **Source**: clone the repository and run `./scripts/install.sh` (macOS/Linux) or `.\scripts\install.ps1` (Windows)

Common entrypoints include `tura` for the interactive TUI, `tura exec "prompt"` for a direct CLI runner, `tura run "prompt"` for a gateway-backed prompt with streaming and history, and `tura_gui` for the desktop GUI workspace client.

## Update: v0.1.33

The latest release is v0.1.33, published on 2026-07-14. The repository was created in July 2026 and has been actively updated, with the last push recorded on 2026-07-18. The roadmap describes the current phase as 0.1.x stabilization, with a planned 0.2 task-planning workspace as the next major milestone. The project invites community benchmark contributions and accepts pull requests with evidence at the test layer.

## Features
- Macro CLI command run — multi-step execution tree in a single LLM turn
- Backward reasoning — guides LLM from goal state backward to root cause
- Runtime context and prompt manager — task-scoped context with CLI compaction
- Test-driven development — reproduces issues before patching
- Interactive terminal UI (TUI) and desktop GUI workspace client
- Multi-session concurrent work with HTML rich text support
- Local HTTP/SSE gateway with optional web GUI serving
- Custom providers, personas, agents, runtime prompts, and commands
- Session DB with per-round archived contracts and verifier results
- Community benchmark with publicly archived artifacts

## Integrations
OpenAI (GPT models), Anthropic/Claude (roadmap), Google/Gemini (roadmap), OpenAI-compatible providers, Local LLM providers (roadmap), npm, GitHub Packages, Cargo/Rust toolchain

## Platforms
WINDOWS, MACOS, LINUX, WEB, API, CLI

## Pricing
Open Source

## Version
v0.1.33

## Links
- Website: https://turaai.net/
- Documentation: https://turaai.net/docs.html
- Repository: https://github.com/Tura-AI/tura
- EveryDev.ai: https://www.everydev.ai/tools/tura