DTS (Deterministic Tool System) is a specialized AI coding agent framework designed exclusively for high-reliability Python development. v0.6.0 🤖

⚖️ The DTS Value Proposition: Quality over Speed

Unlike traditional AI agents that prioritize "instant" responses (often resulting in syntax errors, missing dependencies, or logical hallucinations), DTS invests more time upfront to save you hours of debugging later.

A typical DTS task may take 2-3 minutes to complete. This is because DTS doesn't just "write" code—it validates it through a rigorous 5-stage pipeline before delivery.

• Zero-Debug Delivery: You receive code that is already tested, linted, and verified in an isolated environment.
• Professional Foundation: Designed for experienced developers who need a clean, error-free, and best-practice-compliant skeleton for their projects.
• The Math of Efficiency: More time spent by the agent for correct code = Zero time spent by the human for fixing trivial errors.

🛡️ Local & Private by Design

• 100% Offline: DTS runs entirely on your local machine via Ollama. It does not send or receive any data from the internet.
• Total Privacy: Your code and project data stay on your hardware. No cloud, no telemetry.
• Completely Free: No subscriptions, no API keys, and no hidden costs. You own the compute.

It bridges the gap between Large Language Models and deterministic software engineering practices through a transactional, tool-based protocol specifically optimized for the Python ecosystem.

🧠 Philosophy

The core philosophy of DTS is Determinism over Autonomy. While many agents fail by "looping" or hallucinating, DTS operates through a strict Transactional Protocol.

Every action is a transaction:

1. Immutable Planning: The agent must commit to a plan before executing.
2. Sequence Validation: Mandatory step-locking (X/Y) ensures no steps are skipped.
3. Empirical Investigation: Blind trial-and-error is replaced by mandatory environment analysis upon failure.
4. Five-Stage Validation: Every piece of code must pass AST analysis, Ruff linting, Security Semantic check, Runtime execution test via uv run (Python only), and Black-Box Outcome validation.

🛡️ Security & Professional Integrity

DTS is built by developers for developers. We assume the user has intermediate-to-advanced proficiency with Python and CLI environments. DTS is designed to be non-invasive and ultra-secure:

• Zero-Admin Policy: DTS does not require Administrator privileges and will never modify your system registry or global configurations.
• Sandbox-Ready Logic: Every command is validated against a multi-stage security pipeline before execution to prevent destructive patterns.
• Built-in Toolset: DTS relies exclusively on its internal, audited toolset. It does not use or download external, unverified plugins.
• Precision over Speed: DTS prioritizes deterministic accuracy. While execution time may vary based on hardware, the system's focus is on surgical correctness and procedural stability.

🚀 Key Features (v0.6.0)

• Hardware-Aware Scaling: DTS automatically detects your system VRAM and dynamically configures the KV Cache (Context Window) and Sliding History Window for optimal performance.
• Global Robustness (Universal UTF-8): Full support for non-ASCII characters (Cyrillic, Chinese, etc.) through mandatory UTF-8 environment forcing, preventing encoding errors across all OS platforms.
• Surgical History Retrieval: Enhanced history search tool with context windows, allowing the agent to retrieve the exact surrounding context of past decisions or bugs.
• Hardened Security Pipeline: A Security Linter intercepts "nuclear" patterns (e.g., global asyncio task cancellation, root-level deletions) via AST analysis before execution.
• Black-Box Validation: Outcome validation is opaque to the model, forcing real debugging instead of "cheating" with static prints.

🖥 Hardware & Model Requirements

Reference Model & Protocol Stability

• Qwen 3.6 (27B+): This is the official reference model for DTS operations. It provides the necessary reasoning depth to adhere to the strict deterministic protocol and ensure logical stability.
• ⚠️ Warning on Non-Reference Models: Using models other than the officially supported one is highly likely to result in suboptimal behavior or failures in the JSON tool protocol. While we continuously evaluate new releases, Qwen 3.6 remains the recommended standard for production-grade reliability.

Hardware Requirements & Performance Tiers (Auto-Adaptive)

DTS automatically scales its capabilities based on your available VRAM:

1. Standard Tier (≤ 16GB VRAM):
   • Configuration: 32K Context | 25 Requests History.
   • Best for: Debugging, routine code reviews, and small-to-medium scripts.
   • Limitation: Users should not expect to build highly complex, cross-cutting architectures in this tier. The 32K context window is a physical constraint that may lead to "memory loss" in large, deeply nested projects.
2. Professional Tier (> 16GB - 24GB VRAM):
   • Configuration: 64K Context | 50 Requests History.
   • Best for: Full application development and medium-scale refactoring.
3. Enterprise Tier (> 24GB VRAM):
   • Configuration: 128K Context | 75 Requests History.
   • Best for: Large-scale complex systems, heavy architectural changes, and massive codebase investigations.

• RAM: 32GB (Minimum) | 64GB (Recommended).
• Storage: SSD is mandatory for uv sync and high-speed database operations.

🛠 Prerequisites & Installation (Manual Setup)

We value transparency. DTS stays in its folder and doesn't "magic" its way into your system. You are in total control of the installation.

Mandatory Prerequisites

1. Python 3.12+: Required for deterministic JSON parsing and modern async features.
2. uv: The high-speed package manager. If you have Python installed globally, you can install it simply via pip:

   pip install uv

3. Ollama: Download and install the Ollama client. Once installed, pull the reference model from your CLI:

   ollama pull qwen3.6:27b-q4_K_M

Setup Steps

1. Clone the Repository:

   git clone https://github.com/rsd-dev/DTS.git
   cd DTS

2. Sync Environment: Initialize the isolated virtual environment:

   uv sync

3. Make DTS Global (Recommended): To use DTS from any project folder, you must add the DTS folder to your system PATH:

   • Windows (PowerShell): Add the DTS folder path to your User PATH environment variable.
   • Linux / macOS: Create a symbolic link to dts.sh in your /usr/local/bin or add the DTS folder to your $PATH in .zshrc or .bashrc.

Usage

Important

Environment Control & Speed: To guarantee high-reliability and maximum execution speed, DTS strictly initializes and manages projects using uv. If you have an existing project and you do not wish to manage it via uv, do not use DTS on that project. DTS is designed for users who prioritize deterministic environment orchestration.

1. Start Ollama Server: Ensure the local inference server is running:

   ollama serve

2. Run DTS: Navigate to any folder where you want to start a project and simply type:

   dts

(Windows uses dts.bat, Linux/macOS uses dts.sh)

Note: Instead of the Enter key, use Ctrl + J to submit requests.

⚙️ Adding Custom Preferences

DTS allows you to persist personal coding preferences or specific rules that the agent must always follow. To add a preference, simply type:

pref

And then enter your rule. For example:

• "Always use FastAPI instead of Flask for web projects."
• "Prefer functional programming patterns over classes when possible."
• "Always use double quotes for strings."

These preferences are stored in Agent/preferenze.txt and are automatically injected into the agent's system prompt at every session.

⌨️ CLI Shortcuts

• Ctrl+J: Submit requests.
• exit: Terminate the session.
• pref: Add a custom persistent preference.
• Ctrl+D: Stop the agent generation/current action.

🙏 Acknowledgments

DTS is built upon the extraordinary contributions of the open-source community. Special thanks to:

• Ollama: For providing the essential framework to run high-performance Large Language Models locally and privately.
• Astral: For Ruff and uv, the high-speed tools that guarantee the deterministic quality and isolation of our Python environments.
• Gemini-CLI: For the sophisticated orchestration framework and the intelligent agent architecture that powers the DTS logic.
• Qwen Team: For developing the Qwen 3.6 series, the state-of-the-art LLMs that provide the reasoning depth required for our deterministic protocol.

📜 License & Attribution

DTS is released under the MIT License.

While DTS is free and open-source, if you find this system useful for your commercial software or products, we kindly ask you to provide a brief attribution by mentioning "Developed with the help of DTS (Deterministic Tool System)" and providing a link to the official repository: https://github.com/rsd-dev/DTS. Your support helps the project grow.

---

Developed by RSD Soft.

🛠 Debug & Hotfixes (v0.6.1-dev)

Language Bias Correction (May 13, 2026)

• Issue: Detected a language mismatch where the agent responded in Italian even when prompted in English, despite the preferenze.txt settings.
• Root Cause: The system prompt contained ambiguous language examples that prioritized Italian as a default fallback.
• Fix: Hardened the Agent/system_prompt.txt with a Strict Adherence protocol. DTS now dynamically detects the prompt language and locks its response to match it 100%.
• Result: Verified consistent multilingual support (English/Italian) across different task types.