Turbostar logo Turbostar
Systems & Low-Level Coding

Agentic Coding for Systems Engineers

Turbostar is optimized specifically for systems and low-level development. We equip LLM agents with high-fidelity compiler feedback, sandboxed execution, and context-saving workspaces designed for heavy C++ and Python workspaces.

In-Editor Agent Integration

Pair program with an AI agent that understands your entire workspace. Your embedded assistant can edit files, run builds, launch tests, and fix errors directly alongside you.

  • Split-Window Agent Chat: Chat, ask questions, or delegate coding tasks in a dedicated side-by-side window while watching your code update in real-time.
  • Atomic Code Refactoring: The agent applies clean, precise file modifications directly into your open editor buffers with full undo support.
turbostar --agent-chat
Turbostar Native AI Agent Chat Interface

Virtual Context Paging

Run long multi-hour development sessions without context limits. Turbostar automatically pages history in and out like virtual memory, preserving deep project history while keeping LLM costs low.

  • Tiered Context Optimization: Automatically compresses agent reasoning logs and redundant tool outputs while keeping critical decision context intact.
  • Deep Disk Memory: Every detail is preserved safely on disk, allowing the agent to page earlier context back into memory whenever needed.
turbostar --history-compaction
Turbostar AI Agent Runs Test Suite showing context paging stats

Modular Tool Families

Keep AI agents fast, focused, and affordable. Agents load specialized tool capabilities on-demand, preventing context clutter and model confusion.

  • On-Demand Capabilities: Agents activate tool sets (such as git, image, x86, or hexedit) only when required, keeping prompt sizes small and responses fast.
  • High-Focus Subagents: Spawns specialized subagents equipped only with the exact tools needed for their specific role.
turbostar --tool-families
# Agent activates tool family dynamically:
activate_tool_family(name: "image")
=> Success: Image tool family activated.
   Registered tools available:
   - image_import
   - image_resize
   - image_crop
   - image_export
   Context overhead minimized: loaded 6 tools instead of 40+.

In-Editor Code Review & Edits

Ensure high code quality automatically. AI agents perform inline code reviews, flag potential vulnerabilities, and format code before changes are committed.

  • Interactive Review Cards: Step through agent recommendations directly in the editor and approve or reject edits with single keystrokes.
  • Pre-Execution Security Scans: Automatically scans Python code for security flaws before execution to keep your environment safe.
turbostar --code-review
Turbostar Inline Code Review Screen

Compiler Context Optimization

Save 95%+ of token costs on build errors. Turbostar distills verbose compiler logs into concise, actionable error locations so agents fix build issues on the first attempt.

  • Noise-Free Build Output: Strips out hundreds of lines of successful compilation noise, presenting the agent with only the relevant errors and summaries.
  • Instant Diagnostic Focus: Pinpoints exact failure files and line numbers so the model resolves compiler errors immediately without wasting context tokens.
agentcli --run-build
# Raw compiler output (480 targets compiled)
# [Info] Truncating 476 lines of successful compilation output.
# Retaining summary and diagnostics:

[479/480] Compiling C++ object src/editor_events.cpp.o ... OK
[480/480] Linking target build/turbostar ... OK

Build Success: 480 targets built in 12.4s.
Context Saved: Retained 0.2 KB of 42.1 KB raw output.

Interactive Agent-Driven Debugging

Let your AI agent debug live applications. The agent can launch your program, send test inputs, set GDB breakpoints, and step through code autonomously.

  • Real-Time Interactive Debugging: The agent feeds test cases into stdin while driving GDB in parallel to inspect variable states and isolate runtime bugs.
  • Isolated Test Sandbox: Runs debugging sessions in protected environments to prevent hung processes and ensure host stability.
turbostar --agent-debug
Turbostar Interactive Agent Debugging Split Screen

Autonomous Crash Notifications & Core Dump Inspection

Resolve application crashes automatically. When a test run segfaults, the agent receives an immediate alert and inspects the core dump to find the root cause.

  • Instant Crash Alerts: Execution tools notify the agent the moment a process crashes, providing unique Crash IDs for instant post-mortem analysis.
  • Autonomous Core Dump Analysis: The agent inspects stack backtraces, variable states, and CPU registers via GDB, proposing exact code fixes automatically.
turbostar --agent-gdb-coredump
AI agent interactively debugging a crash with GDB and coredumps in Turbostar

Agent Command Center

Maintain total oversight over multi-agent workflows. The Command Center provides a visual dashboard to monitor subagents, background tasks, and active tool calls.

  • Real-Time Process Tracking: Monitor agent progress, execution states, and task lifecycles across a clean visual dashboard grid.
  • Subagent Hierarchy Control: Inspect parent-child agent trees, view running subagent tasks, or terminate stalled operations with one click.
turbostar --command-center
Turbostar Agent Command Center Dashboard

Integrated Undo History

Code with complete safety and control. All agent modifications are integrated directly into the editor's undo buffer, allowing you to review or revert any change instantly.

  • Granular Step-Back: Review or undo agent edits line-by-line using standard editor undo keys (^K H / Ctrl+Z).
  • Visual Change Highlights: See exactly what lines the agent added, modified, or deleted before approving changes.
turbostar --undo-history
Turbostar Integrated Agent Undo History View

Autonomous CPU Cycle Profiling

Empower agents to optimize application performance automatically. Agents query CPU profiling data to identify bottlenecks and speed up critical inner loops.

  • Direct Bottleneck Discovery: Agents query top functions and line-by-line CPU cycle percentages to pinpoint exact performance bottlenecks.
  • Multi-Run Benchmark Comparison: Compare cycle counts across multiple execution runs (run_1, run_2) to measure optimization gains empirically.
  • Focused Symbol Context: Automatically extracts clean source code blocks around performance hotspots for precise AI refactoring.
turbostar --agent-profile
Turbostar AI Agent CPU Performance Profiling Summary Interface

Interactive Agent Creation & Zero-Porting A2A Server

Create, test, and fine-tune custom subagents interactively—complete with Model Context Protocol (MCP) servers, custom skills, specific AI models, and prompt rules. Once ready, serve those exact agents over the open Agent-to-Agent (A2A) protocol directly from the same environment without writing external wrapper code.

  • Same-Environment Execution: Eliminate the hassle of porting agent definitions, MCP tool configs, or prompt files. Your interactive editing environment directly becomes the headless A2A server (turboserver --server).
  • Zero-Latency Git Worktrees: Serve tasks with --git-worktree mode to instantly provision clean, isolated git worktree checkouts in under 50ms without network cloning or disk pollution.
  • Open Standard OpenAPI Schema: Automatically synthesizes and serves OpenAPI-compliant Agent Cards (/.well-known/agent-card.json) detailing available tools, skills, and parameters.
turboserver --server --git-worktree --a2a-port 7820
# Launch interactive agents directly over A2A:
$ turboserver --server --git-worktree
A2A Server listening: http://0.0.0.0:7820
Card Catalog: 4 subagents published (research, self, securityagent, x86_opt)
Worktree Engine: Private git worktree pre-seeding enabled (< 50ms)

# Serving incoming remote A2A task:
[POST /a2a/v1/agents/research/tasks] -> task-4f8a92b
=> Created worktree: /tmp/turbostar_a2a_task-4f8a92b from HEAD
=> Running subagent with full MCP & skill context...
=> Task completed successfully. Worktree pruned.

Native A2A Client & Remote Agent Orchestration

Delegate complex coding tasks across network boundaries. Turbostar includes a built-in Agent-to-Agent (A2A) client that enables your local agent to discover, connect to, and orchestrate remote agent servers seamlessly.

  • TP7 TUI Server Manager & Tooling: Manage persistent remote servers through a retro Turbo Pascal dialog (A2A Servers...) or programmatically via the a2a_connect_server tool.
  • Remote Namespace Routing: Invoke remote agents effortlessly using server:agent syntax (e.g. invoke_subagent(name: "gpu_box:securityagent")).
  • Automated Workspace Pre-Seeding: Automatically detects your active git repository remote URL and branch, pre-seeding the remote server's workspace so remote subagents start with complete project context on Turn 0.
turbostar --a2a-orchestrator
# Local agent delegates task to remote GPU server:
invoke_subagent(
  name: "gpu_box:securityagent",
  instructions: "Perform full C++ memory safety audit"
)
=> Auto-detected Repo: https://github.com/fenrus75/turbostar2.git
=> Auto-detected Branch: main
=> Dispatching A2A Task: Submitted to http://gpu-box.local:7820
=> Status: Remote workspace pre-seeded. Subagent active...
Task Result: Audit completed (0 warnings found).

Secure Tool Execution

Turbostar provides native secure options for agents, reducing raw shell command risks and eliminating constant permission prompts.

Isolated Namespaces

Agent operations execute within heavily restricted, non-root Linux mount and PID namespaces. The workspace is mounted as read-only by default, preventing arbitrary writes outside of explicitly approved paths.

Bandit Python Scanning

Python tool execution requires automated scans. Any script containing high-severity warnings is blocked from executing natively.

Display & forward controls

Support running graphical X11/SDL2 tests inside the sandbox with secure environment forwarding (XAUTHORITY/DISPLAY bindings).

Context-Aware Tool Libraries

Equips agents with pre-scoped library helper tools that bypass raw shell execution, drastically reducing token usage and context expansion.

Agent Crash Diagnostics

Exposes structured coredump reports and backtrace data generated by libturbocatch.so directly to the agent's tool context for automated debugging.

Specialized Agent Plugins

Support for specialized agent types, including dedicated security code review roles and x86-64 assembly optimization agents.

GitHub Virtual Filesystem

Exposes a native github:// virtual file system prefix, allowing the coding agent to fetch and reference files from any public repository instantly.

Dedicated Python Runner

Features a specialized tool that executes Python code directly in-memory without forcing the agent to write scratch files to disk first, accelerating iteration speed.

Built-in Standards & Extensibility

Turbostar supports the standard agent stack natively to minimize custom orchestration layer code.

Multi-Protocol LLM Support

Run with your preferred provider. Turbostar natively supports Google Gemini, OpenAI (both Completion and Responses APIs), and Anthropic Claude protocols.

Zero-Porting A2A Server Mode

Interactively build custom subagents with full MCP tools, models, and skills, then serve them over A2A directly from the same environment with --git-worktree instant workspace pre-seeding.

Built-in Native A2A Client

Discover, configure, and orchestrate remote A2A agent servers across your network with TUI management dialogs, server:agent routing, and automated repository context pre-seeding.

Model Context Protocol (MCP)

Connect custom servers and tools natively. Turbostar acts as a high-fidelity MCP host for model and tool discovery.

Structured Skill Registration

Define directory-based capabilities (instruction documents, scripts, and examples) that are automatically discovered and loaded into the agent's context.

Customizations & Rules

Inject global or project-level guidelines and constraints into agent turn iterations dynamically using custom markdown configurations.

Claude-Style Subagents

Define helper subagents using standard Markdown profiles with YAML frontmatter, dynamically specifying tool namespaces, permissions, and visual animations.

Dynamic Tool Families

Group agent helper tools into modular namespace families (e.g. git, image, hexedit) that can be activated dynamically on-demand, reducing prompt clutter.