KISS Sorcar: A Stupidly-Simple General-Purpose and Software Engineering AI Assistant
KISS Sorcar combines five layered agents and Git isolation, reaching 62.2% on Terminal Bench 2.0.
Key Findings
Methodology
KISS Sorcar is built on an approximately 2,900-line KISS Agent Framework with five compositional layers. KISS Agent runs budget-tracked ReAct with native function calling; Relentless Agent summarizes trajectories and continues across context windows; Sorcar Agent adds Bash, Read, Edit, Write, browser, Docker, and parallel sub-agents; Chat Sorcar Agent persists bounded history; Worktree Sorcar Agent isolates each task in a Git branch/worktree. Engineering rules are encoded in a hand-tuned system prompt.
Key Results
- On Terminal Bench 2.0, Claude Opus 4.6 with KISS Sorcar achieved a 62.2% overall pass rate, versus 58% for Claude Code and 61.7% for Cursor Composer 2. The authors state that neither prompts nor models were tuned specifically for this benchmark.
- The five core classes contain 463, 431, 685, 497, and 848 significant lines respectively, about 2,924 total. The product catalog includes 504 models across nine provider categories and 23 third-party messaging agents.
- The paper provides no full ablation, confidence intervals, or cost/latency analysis. Evidence therefore combines one benchmark, four months of self-hosting, and system demonstrations rather than isolating causal gains from each layer.
Significance
The work argues that dependable coding agents do not necessarily require sophisticated trajectory compaction or asynchronous multi-agent orchestration. Budget accounting, structured continuation, verification-first execution, and Git isolation directly target finite context, cascading errors, dead ends, AI slop, and irreversible edits. Its Apache-2.0, local-first, bring-your-own-key deployment also reduces privacy concerns and vendor lock-in for researchers and engineering teams.
Technical Contribution
The principal contribution is an interpretable agent stack in which each layer owns one concern. Relentless Agent creates chronological summaries with code snippets and resumes from fresh context; set_model transfers conversation history, tool schemas, and usage counters across vendors; Worktree Sorcar uses branches, locks, Git metadata, and recovery logic for concurrent isolation. This is an engineering contribution rather than a new training objective or formal guarantee.
Novelty
The novelty is systems integration and disciplined simplification, not a new learning algorithm. Unlike typical single-session, single-vendor assistants optimized for speed, KISS Sorcar combines continuation, dynamic multi-provider switching, persistent chat, browser and messaging tools, and per-task Git worktrees in a compact open-source framework of roughly 2,900 lines.
Limitations
- Evaluation is dominated by one aggregate Terminal Bench 2.0 score. Without task-level breakdowns, repeated trials, ablations, or confidence intervals, it is unclear which layers cause the reported advantage and whether it generalizes.
- Summaries may grow unwieldy in multi-day tasks, a limitation acknowledged by the authors. Git isolation also weakens when a repository has no commits, a detached HEAD, or is not a Git repository, because the system falls back to direct execution.
Future Work
Future work should measure summary scaling, conduct layer-by-layer ablations, report cost-quality-latency trade-offs, and evaluate more benchmarks. Promising directions include stronger context compression, permission systems, sandboxing, reproducible multi-agent orchestration, and statistical studies of model switching and verification.
AI Executive Summary
Large language models can write code, reason about architecture, and call tools, yet long software-engineering tasks remain fragile. Finite context, one error contaminating later decisions, repeated dead ends, low-quality AI-generated code, and difficult rollback all make fluent models unreliable as autonomous collaborators.
KISS Sorcar responds with a deliberately small five-layer framework. KISS Agent executes budget-tracked ReAct with native function calling; Relentless Agent summarizes progress and continues in a fresh context; Sorcar Agent adds coding tools, Playwright browser automation, Docker, and parallel workers; Chat Sorcar Agent preserves bounded conversational history; Worktree Sorcar Agent gives every task its own Git branch. The set_model tool can transfer a live conversation among OpenAI, Anthropic, Gemini, and other providers.
The system runs locally through a VS Code extension, CLI, and web/mobile interface. It prioritizes verification over speed, asking frontier models to run linters, type checkers, and tests. With Claude Opus 4.6, it achieved 62.2% on Terminal Bench 2.0, compared with 58% for Claude Code and 61.7% for Cursor Composer 2. The result is promising, especially given the lack of benchmark-specific tuning, but the paper does not provide complete ablations, cost analysis, or uncertainty estimates. It is best read as a strong engineering case study for simple, recoverable agent architecture rather than a definitive scientific demonstration.
Deep Analysis
Background
Coding agents have evolved from issue-solving systems to general software assistants. ReAct, Reflexion, Claude Code, Cursor, GEPA, AlphaEvolve, and OpenEvolve demonstrate tool use, self-critique, prompt optimization, and code search. However, context limits, unreliable recovery, unsafe direct edits, and weak evaluation remain unresolved. KISS Sorcar studies whether conventional engineering discipline can address these failures with a compact framework.
Core Problem
A practical agent must complete many dependent actions under finite context and token budgets. Errors can propagate, retries can loop, and a live working tree can be damaged before a human reviews the change. One model may also be poor at both exploration and deep verification. The challenge is to provide persistence, recovery, model flexibility, and safe integration without excessive architectural complexity.
Innovation
- ��Single-concern layering separates execution, continuation, tools, memory, and isolation. •Relentless Agent uses chronological summaries instead of sophisticated trajectory compaction. •set_model turns model choice into a task-level programmable resource while preserving history and accounting. •Worktree Sorcar provides branch-per-task isolation, locking, dirty-state preservation, and crash recovery. •A local daemon coordinates VS Code, CLI, and web/mobile surfaces, while supporting 504 models and 23 messaging agents.
Methodology
- ��Input: a task, model, tools, and budgets. KISS Agent runs a native-function-calling ReAct loop, tracking input/output tokens, dollar cost, steps, and global budget. •Continuation: finish(success, is_continue, summary) triggers a new context; failure causes a summarizer agent to inspect the saved trajectory. •Execution: Sorcar Agent exposes Bash, Read, Edit, Write, Chromium/Playwright, Docker-aware tools, user questions, and thread-pool parallelism. •Collaboration: set_model migrates the transcript, cumulative counters, and provider-specific schemas, enabling scout-then-edit and generate-then-review workflows. •Isolation: Worktree Sorcar creates a branch and worktree, uses a baseline commit and cherry-pick, and serializes repository operations with locks.
Experiments
The principal evaluation is Terminal Bench 2.0. KISS Sorcar uses Claude Opus 4.6 and is compared with Claude Code and Cursor Composer 2 using overall pass rate. Reported scores are 62.2%, 58%, and 61.7%, respectively; the authors claim no benchmark-specific prompt or model tuning. Additional evidence includes four months of self-hosted development, class-level line counts, and feature demonstrations. No complete ablation, repeated-run variance, latency, or cost experiment is reported.
Results
KISS Sorcar leads Claude Code by 4.2 percentage points and Cursor by 0.5 points on the reported benchmark. The result is consistent with the paper’s quality-first design, but cannot establish which mechanism matters. The 504-model catalog, dynamic switching, and local deployment broaden usability, yet their independent effect on Terminal Bench performance is not measured.
Applications
Developers can ask the agent to inspect repositories, edit code, browse documentation, run tests, and review diffs from VS Code, CLI, or web interfaces. Teams can use Docker, local endpoints, and bring-your-own keys for sensitive work. Researchers can drive GEPA prompt optimization, algorithmic search, or repository optimization with high-level prompts. Git and model-provider configuration remain prerequisites.
Limitations & Outlook
The system inherits the reliability, latency, and cost of external models, and summaries can omit state or preserve mistaken assumptions. Parallel workers and model switching may add coordination overhead. A single aggregate benchmark is insufficient for broad claims, while non-Git directories lose worktree protection. Future evaluations need task-level statistics, reproducible seeds, human review burden, security testing, and explicit cost-quality trade-offs.
Plain Language Accessible to non-experts
Imagine a repair factory serving many complicated orders. One supervisor performs each step while watching the budget. A clerk writes a chronological work log when the shift ends, so the next shift can continue without starting over. Workers can read documents, edit parts, browse the web, and run quality checks; several workers can investigate different questions at once.
Every order receives its own workshop. If a worker makes a mess, the customer’s main workshop remains untouched. The customer can inspect the difference, accept it, or throw away the entire branch. A cheap worker can scout the problem, a skilled worker can build the solution, and another worker can independently inspect it.
The factory’s achievement is not a magical new machine. It is clear division of labor, bookkeeping, testing, and safe separation. KISS Sorcar reached 62.2% on Terminal Bench 2.0, but more experiments are needed to show which departments create the improvement and whether the extra checking is worth its time and cost.
ELI14 Explained like you're 14
Think of an AI teammate helping you build a huge game level. A normal teammate might forget the plan after a while, repeat the same failed move, or edit your main save file and ruin it. KISS Sorcar organizes a whole squad: one teammate acts step by step and tracks the score, another writes a progress diary, and a fresh teammate continues from that diary.
Other teammates can read files, change code, open websites, and run tests. They can work on different clues at the same time. You can even ask a fast model to search first, then switch to a stronger model to build and review the fix. Every job gets a separate Git branch, like copying a game save before trying a risky experiment.
It works in VS Code, a terminal, or a browser. With Claude Opus 4.6, it passed 62.2% of Terminal Bench 2.0 tasks, compared with 58% for Claude Code and 61.7% for Cursor. Pretty impressive! But it is not an always-correct robot: it can misunderstand instructions, and its diary can grow too long. More testing is still needed.
Glossary
ReAct
A loop in which a model reasons, takes an external action, observes the result, and continues. KISS Agent uses native function calling to implement this loop.
The innermost execution layer.
Relentless Agent
A wrapper that continues a task across fresh context windows. It creates chronological progress summaries containing explanations and relevant code snippets.
Addresses context and step limits.
Git worktree
An independent working directory associated with a Git branch. KISS Sorcar uses one per task to protect the user’s main tree.
The outer isolation layer.
MCP
Model Context Protocol, a standardized way to connect models with external tools and services. Sorcar can discover and manage MCP servers.
Tool and integration extensibility.
GEPA
A prompt-optimization approach that improves instructions using feedback or evaluation. The framework supports GEPA drivers, although the production system prompt was hand-tuned.
AI-discovery and optimization workflows.
Terminal Bench 2.0
A benchmark for agents solving terminal-based software tasks. The paper reports a 62.2% overall pass rate for KISS Sorcar with Claude Opus 4.6.
Primary comparative evaluation.
Open Questions Unanswered questions from this research
- 1 The causal value of each layer is unknown; controlled ablations, repeated runs, task categories, and confidence intervals are needed.
- 2 Summary scaling over multi-day tasks remains unevaluated. It is unclear when summaries become too large, omit critical state, or propagate an early mistake.
- 3 The 62.2% score is not paired with token cost, wall-clock latency, or human review effort, so the economic value of quality-first execution is unresolved.
Applications
Immediate Applications
Isolated code maintenance
A developer submits a repair request from VS Code or the CLI. Sorcar edits a dedicated Git worktree, runs linters, type checkers, and tests, and presents a diff for approval. A Git repository and configured model endpoint are required.
Multi-model code review
A fast model such as Gemini 2.5 Flash can scout the repository, Claude Opus 4.7 can implement the change, and gpt-4o can independently review it and generate regression tests. set_model keeps the task history and usage accounting coherent.
Long-term Vision
Auditable local engineering automation
The framework could connect repositories, messaging, deployment, and research tools into an auditable development pipeline. Major obstacles are permission control, sandbox security, model failures, cost governance, and reliable cross-task evaluation.
Abstract
Large language models can generate code and call tools fluently, yet deploying them as practical assistants for long-horizon software engineering and AI-discovery tasks still exposes persistent gaps: finite context windows, a single mistake that can derail entire sessions, agents that get stuck in dead ends, AI slop, and generated changes that are difficult to review or revert. We present KISS Sorcar, an open-source general-purpose AI agent for long-horizon tasks and AI discovery that doubles as an integrated development environment (IDE). It is built on top of the KISS Agent Framework, a stupidly-simple AI agent framework of roughly 2,900 lines of code for the core agents. The framework addresses the gaps above through a structured system prompt and a five-layer agent hierarchy in which each layer adds exactly one concern: budget-tracked ReAct execution, automatic continuation across sub-sessions via summarization, coding and browser tools with parallel sub-agents, persistent multi-turn chat with history recall, and git worktree isolation so every task runs on its own branch. Engineering principles are encoded in the agent's system prompt.