KISS Sorcar: A Stupidly-Simple General-Purpose and Software Engineering AI Assistant

Abstract: LLMs can generate code and call tools with remarkable fluency, yet deploying them as practical software engineering assistants still expose stubborn gaps: finite context windows, single mistakes that 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, a general-purpose assistant and integrated development environment (IDE) built on top of the KISS Agent Framework, a stupidly-simple AI agent framework of roughly 1,850 lines of code. The framework addresses these gaps using a robust system prompt and through 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. To assess the power of the KISS agent framework, we implemented KISS Sorcar as a free, open-source Visual Studio Code extension that runs locally and effectively for long-horizon tasks, and supports browser automation, multimodal input, and Docker containers. In this research, we deliberately prioritize output quality over latency: giving a frontier model adequate time to validate its own output -- running linters, type checkers, and tests -- dramatically reduces the low-quality code that plagues faster but less thorough agents. The entire system was built using itself in 4.5 months, providing a continuous stress test in which any agent-introduced bug immediately impairs its own ability to work. On Terminal Bench 2.0, KISS Sorcar achieves a 62.2% overall pass rate with Claude Opus 4.6, comparing favorably to Claude Code (58%) and Cursor Composer 2 (61.7).

• The paper introduces a five-layer agent framework implementing cost-controlled ReAct loops and robust error handling via modular design.
• It integrates tools like browser automation, file manipulation, and git worktree isolation to manage complex, long-horizon coding tasks.
• Evaluation on Terminal Bench 2.0 shows a 62.2% pass rate, underscoring the benefits of reproducible engineering practices over complex orchestration.

KISS Sorcar: Layered Simplicity for Autonomous Software Engineering Agents

Overview

“KISS Sorcar: A Stupidly-Simple General-Purpose and Software Engineering AI Assistant” (2604.23822) proposes a compact, layered agent framework for autonomous software engineering, with minimal abstraction and direct concern isolation. Unlike complex orchestration-heavy architectures, KISS Sorcar implements a five-layer hierarchy, each layer addressing an orthogonal practical requirement: robust, cost-bound ReAct loop execution, automatic continuation via summarization, parallelized coding and browser tools, chat history persistence, and git worktree isolation per task. The system is instantiated as a VS Code extension that operates locally, automates long-horizon coding workflows, and robustly handles context/window limitations, agent error states, and version control safety.

Agent Architecture and Implementation

The KISS Agent Framework is comprised of approximately 1,850 lines of Python, distributed across five strictly compositional layers:

• KISS Agent: A budget-aware, stateless, native ReAct loop providing function-calling interfaces, detailed step/budget tracking, and automatic error resilience. Tools are implemented as regular Python callables, with OpenAI-compatible schemas cached and input/output tokens precisely costed per trial.
• Relentless Agent: Implements a continuation protocol for tasks exceeding single context/session limits. When the session is exhausted (by tokens or steps), a chronologically structured summary (containing actions and code snippets) is generated and passed as context for the next segment. This mechanism obviates context-compaction tricks in favor of persistent, human-auditable progress summarization.
• Sorcar Agent: Integrates a tightly scoped set of tools for direct shell execution, file manipulation, browser automation using Playwright, parallel execution for embarrassingly parallel tasks (thread pool), user interaction, and Docker-based sandboxing. Tool usage patterns are explicitly prescribed to avoid ambiguous or destructive operations.
• Chat Sorcar Agent: Provides durable chat-based interfaces, supporting multi-turn persistence, prompt context injection of prior exchanges, metadata logging (including cost, token, and execution details), and flexible session resumption.
• Worktree Sorcar Agent: Ensures all code edits are isolated to temporary git worktrees (branch-per-task). State is durably preserved in git (not sidecar files), with built-in concurrency safety, dirty-state snapshotting, and crash recovery.

These layers yield a single-concern-per-layer design, enabling compositional reasoning and straightforward debugging in both agentic execution and the framework itself.

System Prompt Engineering

A core contribution is the “structured system prompt”—an instructional substrate encoding engineering discipline, tool rules, verification protocols, and failure mode avoidance directly for the underlying LLM.

Key protocol sections:

• Execution Mindset: Mandates sequential focus, calmness, rigor, and factual correctness, explicitly banning “AI slop” or filler output.
• Tool Usage: Mechanical rules for atomic edits (distinguishing Write/Edit), bash timeouts, chunked file reads, and explicit chunked web/file research.
• Pre-flight and Pre-finish Checks: Compulsive file reading before modification, test-before-fix discipline, root-cause analysis, and step-by-step pre-finish checklists to enforce explicit verification prior to declaring a task complete.
• Self-improvement: Local USER_PREFS.md invariants for agent self-accretion of user preferences, fully conflicted and deduplicated, without embedding brittle code snippets.
• Continuation/Recovery: Specific handoffs on near-exhaustion of context/steps and robust summarization for failed or interrupted trajectories.
• Web/File Research Protocols: Two-phase (collect-then-synthesize) information gathering, enforcing coverage breadth and auditability before synthesizing or acting on external or cross-file data.

By combining modular agent architecture with system prompt formalism, the framework aims to close the gap between LLM generation quality and professional engineering workflow discipline.

VS Code Extension and User-Facing Features

KISS Sorcar is implemented as a VS Code extension providing:

Figure 1: Screenshot of KISS Sorcar running as a VS Code extension, capturing real-time agent interaction, code edits, and token/cost tracking.

• Live per-task and global budget tracking and enforcement, providing cost transparency and aligning agentic operation with economic constraints.
• User-editable chatbot interface, which persists conversational history and session context.
• Direct browser automation and preview embedding for agent-driven web interactions.
• Real-time self-improvement loop via incremental USER_PREFS.md editing and conflict resolution.
• Safe worktree code isolation and crash recovery; agent changes are always reversible and auditable, and end-user codebase integrity is scrupulously protected.
• Automated linter/typechecker/test suite invocation before declaring task completion.

Evaluation

On Terminal Bench 2.0—comprising 89 terminal-based multi-file tasks—KISS Sorcar, using Claude Opus 4.6 as its LLM backend, achieves a 62.2% overall pass rate (277/445, 5 trials per task). This outperforms Claude Code (58%) and Cursor Composer 2 (61.7%) on the same tasks and model, despite using no specialized fine-tuning, RL, or micro-optimization. Task-level diagnostics are provided: 39/89 always-passed, 19/89 always-failed (mostly due to environment or domain-extreme requirements), with the remainder exhibiting stochasticity related to modeling or environment constraints. Median trial cost was $0.45 per trial, with clear tracking of durations and cost ceilings.

The authors highlight systemic benchmark contamination and harness-level cheating in competing agentic systems, juxtaposing KISS Sorcar’s strictly “cheat-free” and reproducible evaluation protocol.

Practical and Theoretical Implications

Practically, KISS Sorcar demonstrates that a minimal, single-responsibility agent composition, combined with explicit prompt-encoded workflow discipline, suffices for high-performing, robust agentic software engineering under real-world constraints (limited context, long-horizon tasks, practical cost). The engineering discipline encoded in the prompt (forced file reviews, explicit verification, root-cause bugging) systematizes practices that, when followed by human engineers, lead to fewer mistakes and more reliable output. The strong isolation guarantees (worktree-per-task, fail-safe recovery) provide a foundation for integrating autonomous agents into human software engineering workflows without risking codebase corruption or spurious merges.

Theoretically, the work suggests diminishing returns for larger or more complex orchestration; modular, minimal, single-concern agent layering synergizes with LLMs when complemented by formal, enforceable system prompts. Additionally, the agent demonstrates that output verification and tool-driven self-checks via robust prompt engineering are more critical than parametric model scaling, at least within the current capability regime of frontier LLMs (e.g., Opus 4.6).

Future Directions

Extension to multimodal reasoning, enlarged toolsets, and improved summarization for extremely long-horizon tasks are plausible next steps. The framework’s open-source accessibility and model-agnostic design mean it can quickly benefit from improvements in LLM quality or cost, third-party tool integrations, or further advances in prompt engineering. The approach also foregrounds the need for “prompt-based discipline encoding” as a first-class research area in practical agentic software engineering.

Finally, the authors posit that continued LLM improvements may obsolete large swathes of ad hoc academic research, and that for practical software engineering, expert command, robust agent prompting, and integration discipline will become the principal bottlenecks, rather than base model intelligence or agentic control.

Conclusion

KISS Sorcar provides a concise, effective, and rigorously engineered framework for agentic software engineering. By eschewing complex abstraction and instead focusing on modular, orthogonally layered agent design and explicit system prompt formalization, the framework achieves strong, reproducible results on real-world multi-step coding tasks. The approach is distinguished by enforcement of cost and verification discipline, robust fault tolerance, and auditable, tool-integrated workflows, marking a significant step in the maturation of practical autonomous software engineering agents (2604.23822).