Tura: 16,7% betere prestaties, 77,5% minder tokens

Over 20 DeepSWE v1.1-taken, waarbij elke run drie keer per agent werd uitgevoerd, creëert Tura een aanzienlijk voordeel in het tokenbudget door herhaalde context en model-roundtrips te verminderen. Dit voordeel kan op twee manieren worden ingezet:

  • Direct: Richt het grootste deel van het voordeel op lagere kosten. Dit resulteert in 77,5% minder geaggregeerde tokens dan Codex CLI, met een vergelijkbaar succespercentage van de verifieerder (65,0% tegenover 63,3%).
  • Balanced: Investeert meer van het bespaarde budget terug in redenering, onderzoek en verificatie. Deze configuratie bereikte een succespercentage van 80,0%, wat 16,7 procentpunt hoger is dan Codex CLI, terwijl er nog steeds 31,1% minder tokens werden gebruikt.

Benchmark

Benchmarks voor taken met een lange horizon (long-horizon tasks) zijn een manier om verder te kijken dan een gepolijste, geïsoleerde prompt en te zien hoe een agent daadwerkelijk werk afhandelt. De gepubliceerde vergelijking maakt gebruik van harness-gebaseerde ontwikkelingstaken met gearchiveerde prompts, tool-aanroepen per ronde, tokengebruik, patches en resultaten van de verifieerder.

De gepubliceerde artefacten vergelijken de configuraties Tura Balanced, Tura Direct en Codex CLI op:

  • 20 DeepSWE-taken;
  • 5 rewrite-taken;
  • 2 afzonderlijk beoordeelde designtaken (huidig record van de testset).

De gepubliceerde resultaten vestigen geen equivalente kwaliteit of prestaties voor elke geconfigureerde provider. Bredere metingen voor Anthropic/Claude, Google/Gemini, OpenAI-compatibele providers, lokale providers, UI-latentie, runtime/sessie-parsing en cross-OS metingen maken deel uit van de gedocumenteerde roadmap en bekende bewijslacunes.

Volledig Benchmarkrapport

Harness-succes en geaggregeerd tokengebruik over 25 taken met een hoge moeilijkheidsgraad, 6 agent- en modelconfiguraties en 270 sessies. Bronnen en berekeningsnotities zijn onderaan gekoppeld.

Macro CLI Command Run

De meeste coding agents zijn nog steeds afhankelijk van repetitieve tool-aanroepsites: inspecteren, wachten, patchen, wachten, bouwen, wachten, testen, wachten.

Voorbeeld van een standaard tool-aanroepende coding agent:

# Turn 1 : inspect environment
rg -n "TODO|command_run|handler" crates/
rg --files crates/runtime/src crates/tools/src

# Turn 2 : apply patch
*** Begin Patch
*** Update File: crates/tools/src/command_run/handler.rs
@@
-    // old command handler logic
+    // patched command handler logic
*** End Patch

# Turn 3 : build
cargo build -p runtime

# Turn 4 : run tests
cargo test -p runtime --lib

# Turn 5 : run lint validation
cargo clippy -p runtime --all-targets

Tura kiest een andere route. In plaats van tientallen kleine tools aan het model bloot te stellen, stelt het één macro-tool beschikbaar: command_run. De agent kan vervolgens een uitvoeringstree met meerdere stappen bouwen en gerelateerde acties in één LLM-turn uitvoeren.

In het onderstaande voorbeeld voeren beide agents dezelfde commando's uit. Een normale tool-aanroepende agent heeft vijf LLM-turns nodig; Tura handelt de sequentie af als één gestructureerde macro-workflow. De bespaarde arbeid is conversationele overhead, geen engineering discipline.

Tura macro CLI command:

{
  "name": "command_run",
  "arguments": {
    "commands": [
      {
        "step": 1,
        "command_type": "shell_command",
        "command_line": "rg -n \"TODO|command_run|handler\" crates/"
      },
      {
        "step": 1,
        "command_type": "shell_command",
        "command_line": "rg --files crates/runtime/src crates/tools/src"
      },
      {
        "step": 2,
        "command_type": "apply_patch",
        "command_line": "*** Begin Patch\n*** Update File: crates/tools/src/command_run/handler.rs\n@@\n-    // old command handler logic\n+    // patched command handler logic\n*** End Patch"
      },
      {
        "step": 3,
        "command_type": "shell_command",
        "command_line": "cargo build -p runtime"
      },
      {
        "step": 4,
        "command_type": "shell_command",
        "command_line": "cargo test -p runtime --lib"
      },
      {
        "step": 4,
        "command_type": "shell_command",
        "command_line": "cargo clippy -p runtime --all-targets"
      }
    ]
  }
}

Er is geen ablatietest die bewijst dat command_run alleen verantwoordelijk is voor het lagere aantal turns en tokens van Tura. In de volledige DeepSWE-vergelijking gebruikte Balanced echter 35,8% minder turns en 31,1% minder tokens dan Codex CLI, terwijl Direct 69,1% minder turns en 77,5% minder tokens gebruikte.

Backward Reasoning (Achterwaartse Redenering)

Hoe indrukwekkend LLM's ook kunnen zijn, een LLM is in de kern nog steeds een statistisch inductiemodel op basis van tekst-token-waarschijnlijkheden.

Voorbeeld: het vragen aan een LLM om te kiezen tussen steen, papier en schaar garandeert geen uniform willekeurig resultaat. Als een echte verdeling van één-op-drie essentieel is, heeft de keuze een externe bron voor willekeurige getallen nodig in plaats van een niet-geciteerde aanname over model-outputwaarschijnlijkheden. In coding-taken is dit vaak fataal.

Een agent is eerder geneigd code en logica te genereren die statistisch vaker voorkomen. Maar veelvoorkomende code en logica zijn vaak middelmatig en onvoldoende doordacht. Tura hanteert een andere strategie.

Tijdens het redeneren gaat een gangbare agent uit van de huidige staat naar het doel van de prompt. In dat geval is $s1$ de huidige staat en is $sn$ het doel dat door de gebruikersprompt is gegeven: $$s1 \rightarrow s2 \rightarrow s3 \rightarrow \cdots \rightarrow sn$$

In plaats daarvan stuurt Tura de LLM aan om eerst $s{n-1}$ statistisch te schatten, en vervolgens achterwaarts te redeneren van de staat $s{n-1}$ naar $s_{n-2}$.

Voorbeeld: optimale strategie voor steen-papier-schaar

Om steen-papier-schaar eerlijk en uitdagend te houden,
hebben we onbevooroordeeld spel nodig.
Elke zet moet een echte kans van één-op-drie hebben.
Een LLM kan dat niet garanderen op basis van tekstwaarschijnlijkheden alleen.
Gebruik een random-number generator script om randint(1, 3) te genereren.
Koppel vervolgens steen, papier of schaar aan het getal.

Bij programmeringstaken betekent dit dat wanneer een agent een doel ziet zoals het oplossen van een frontend-bug, hij wordt gestuurd om door het volledige executiepad te redeneren, de foutstatus te reconstrueren en de bronoorzaak te identificeren voordat er code wordt geschreven. In de gepubliceerde DeepSWE-vergelijking behaalde Tura Balanced 10 van de 60 binaire taakverifieerders meer dan Codex CLI.

In een subset van dezelfde 20 taken tonen de officiële mini-swe-agent resultaten van DeepSWE een kloof van 8% tussen GPT-5.6 SOL High en Medium reasoning, terwijl Tura Balanced met 16,7% leidt op Codex CLI. Dit wijst erop dat een hogere redeneerinspanning alleen niet het voordeel van Tura verklaart.

Runtime Context en Prompt Manager

Skills zijn vaak niets anders dan zwakkere prompts die in de context zijn geladen. In veel agent-frameworks blijft een langdurige sessie skill-bestanden, tool-outputs en verouderde taakgeschiedenis accumuleren. Wanneer de context te groot wordt, gaat de agent over tot een aparte compactieturn, maar deze compactie bewaart meestal alleen een samengevatte versie. Belangrijke details van de uitvoering kunnen vaag worden of verloren gaan.

Tura behandelt context als onderdeel van de runtime state machine. In plaats van te vertrouwen op gebruikers om handmatig sessies te resetten of Markdown-skills op te stapelen, gebruikt Tura task_status, runtime prompts en recursieve uitvoeringshandleidingen om de actieve context beperkt te houden tot de huidige taak.

Traditionele skill-gebaseerde agents houden meestal één sessie actief tot de gebruiker een nieuwe start, laden brede Markdown-skills in die sessie en laten deze actief tot een reset of compactie. Tura koppelt runtime prompts aan expliciete taakstaten:

  • Sessies kunnen worden hernoemd, ververst en automatisch beheerd;
  • Taakspecifieke handleidingen en CLI-commando's worden geladen via een recursieve taakboom;
  • Irrelevante context kan via de CLI worden verwijderd, vervangen of gecompacteerd.

Het checkpoint kan codelocaties, patches, tests en taakstatus behouden in plaats van alleen een losse samenvatting. In de praktijk betekent dit minder verouderde context, lagere tokenkosten per taak en minder kansen dat een oude skill of vage samenvatting de huidige opdracht beïnvloedt.

Omdat compactie een CLI-operatie is, kan Tura de exacte uitvoeringsstaat bewaren in taskstatus.compactcontext. In de gepubliceerde benchmarksessies ging Tura voorbij aan read-only inspectie en hervatte de uitvoering gemiddeld 2,6 rondes na compactie, vergeleken met een geschat aantal van 5,4 rondes voor Codex.

Noot: Het resultaat van 2,6 rondes voor Tura is berekend op basis van expliciete compact_context-events in de gearchiveerde round contracts. Codex exposeert geen equivalente compactie-events; het resultaat van 5,4 rondes is daarom geschat vanaf punten waar het input-tokengebruik scherp daalt, exclusief identificeerbare media-leesgrenzen.

Installatie en uitvoering

NPM release

Mac en Linux:

npm install tura-ai
tura

Windows:

npm install -g tura-ai
tura

Hetzelfde hoofdpackage is ook gepubliceerd op GitHub Packages als @tura-ai/tura. Configureer de @tura-ai scope voor https://npm.pkg.github.com, authenticatie met een token dat read:packages heeft, en installeer dan @tura-ai/tura. Het ongescopte tura-ai package op npm blijft de eenvoudigste publieke installatiemethode.

Tura bevat geen provider-credentials. Configureer bij de eerste start een LLM-provider en selecteer een model voordat u een prompt verzendt. Zie Provider setup voor de CLI, TUI en GUI flows.

Source checkout

Windows PowerShell:

git clone https://github.com/Tura-AI/tura.git
cd tura
.\scripts\install.ps1
tura

macOS of Linux shell:

git clone https://github.com/Tura-AI/tura.git
cd tura
./scripts/install.sh
tura

De source installer voert de volledige omgevingssetup, release build en user PATH registratie uit. Gebruik -EnvironmentOnly op PowerShell of --environment-only op macOS/Linux alleen wanneer u bewust dependency setup wilt zonder Tura te bouwen of te registreren.

Veelvoorkomende entrypoints

CommandoGebruik
turaInteractieve terminal UI (TUI).
tura "prompt"Open de TUI met een initiële prompt.
tura exec "prompt"Directe Rust CLI prompt runner.
tura run "prompt"Gateway-backed prompt met streaming/historie.
tura bash, tura zsh, tura shelPrompt met een geselecteerd command-run shell oppervlak.
tura_gatewayLokale HTTP/SSE gateway en optionele web GUI serving.
tura_guiDesktop GUI workspace client.

Documentatie

De index van de GitBook-stijl documentatie is te vinden in docs/SUMMARY.md. De volledige navigatiepagina staat in docs/start/navigation.md.

Onderwerpen:

  • Start: Overzicht, Installatie, Hoe te starten, CLI parameters, Instellingen, Providers, Sessies, Navigatie.
  • Core: Taakstatus, Contextbeheer, Runtime prompt, Command run, Commando's, Agents, Personas, Rich text, Dynamische prompt-injectie.
  • Architectuur: Systeemarchitectuur, Runtime/Sessie equivalentiepoort, Sessie DB, Gateway, Router, Runtime, Tool, Terminal User Interface, Graphic User Interface.
  • Customization: Custom providers, Custom personas, Custom agents, Custom runtime prompts, Custom commando's.
  • Ontwikkeling: Scripts, Testing, Omgeving.

Bijdragen en Bestuur

Bijdragen dienen klein, reviewbaar en ondersteund te worden door bewijsmateriaal op de testlaag die het betreffende gedrag beheert. Kies het passende issue- en pull-request type.

  • Contributing: Start hier voor bijdragings-types, ontwikkelsetup, testselectie en stappen voor pull-requests.
  • Contribution guide: Test-eigendom, beïnvloede matrices, prestatiebewijzen en regels voor artifact-sanitering.
  • Roadmap: Huidige prioriteiten voor 0.1.x stabilisatie en de geplande 0.2 taakplanning workspace.
  • Known issues and evidence gaps: Open architectuur, provider, benchmark, prestaties en cross-OS werk.
  • Code of Conduct: Gemeenschapsnormen en het open agent-harness principe.
  • Security policy: Ondersteunde versies en private rapportage van kwetsbaarheden.

Licentie

Tura is gelicenseerd onder AGPL-3.0-or-later. Zie LICENSE.

***

Voetnoten en bronnen

  1. DeepSWE en Rewrite Repo vergelijking: De figuur vermeldt de taak, sessie, verifieerder, turn, token en aggregatiescopes gebruikt in de README.
  2. tura-benchmark DeepSWE replicate 1, 2 en 3: Elke manifest bevat 20 taken over dezelfde drie agentconfiguraties; samen bevatten ze 180 sessies.
  3. tura-benchmark current test-set record: Inclusief directe links naar alle acht gepubliceerde design HTML artefacten en hun run contracts.
  4. tura-benchmark GPT-5.6 Rewrite Repo canonical manifest: De geciteerde totalen zijn Tura Balanced 389/472 en Codex CLI 351/472 over 10 sessies elk.
  5. tura-benchmark DynamoDB: ronde 107 compact en ronde 114 eerste latere patch.
  6. tura-benchmark Wasmi replicate 1: ronde 43 compact en ronde 44 eerste non-read actie. De run eindigt bij ronde 46 zonder latere patch of testactie.
  7. tura-benchmark Wasmi replicate 2: ronde 26 compact, ronde 28 eerste non-read actie, en ronde 39 eerste latere patch/test.
  8. tura-benchmark Wasmi replicate 3: ronde 39 compact en ronde 41 eerste latere patch/test.
  9. tura-benchmark eza: ronde 23 compact en ronde 24 eerste latere test.