TAO·CODER
Autonomous coding agent with structured task memory, role modes, parallel task execution, and stage pipeline — right in your IDE.
Download on VS Marketplace | Website
TAO·CODER is an AI coding agent that operates in role modes, follows explicit task stages, and stores context in structured external memory rather than an ever-growing chat history.
The agent replaces linear dialogue history with a managed pipeline of bounded prompts, an update cycle, and strict tool permissions at each stage. This architecture is specifically designed to work efficiently with fast, cost-effective flash models while maintaining high code quality and precision over long execution distances — including parallel work on multiple tasks within a single project.
Table of Contents
Who Is This For
TAO·CODER is built for developers and teams who need structured, reliable AI-assisted development — not just code generation.
Ideal users:
- Developers with large codebases (100+ files) — TAO·CODER's Task Context and bounded prompts handle long-distance precision without losing context
- Teams that need process — stage-gated execution ensures analysis before implementation, audit before delivery
- Engineers who want control — review specs, edit plans, mark references stale, manage snapshots — all through the Task Context Cockpit
- Cost-conscious developers — TAO·CODER is architecturally designed for flash models, making LLM costs predictable and low. A hard-working developer won't exceed $500/month even with heavy daily use, and the practical "unlimited" threshold is around $300/month — 10-30x cheaper than classic AI coding agents running frontier models
- Ops/DevOps teams — Ops mode for deployment, monitoring, rollback; scheduled tasks for automated checks
- Non-coding workflows — Custom Role Modes extend TAO·CODER beyond code: research, content creation, log analysis, documentation
Not ideal for:
- Quick one-liner scripts or simple edits (use Free mode, but the full power shines on complex tasks)
- Developers who prefer unstructured chat-based AI assistants
- Projects where speed matters more than quality and traceability
Built-in Development Methodology
TAO·CODER is not just a code generator — it embeds a complete AI development methodology into every task. The agent doesn't "write code somehow"; it follows a structured process with explicit stages, tool permissions, and quality gates.
What's Built In
1. Stage-Gated Execution
Every task flows through explicit stages. Write access is locked during analysis stages — the agent cannot modify code until it has:
- Clarified requirements and written them into the Task Context
- Collected data (read files, searched patterns, explored dependencies)
- Created an implementation plan with acceptance criteria
This prevents the common AI coding failure mode: jumping to implementation without understanding the problem.
2. Architectural Document Structure
The Architect mode enforces a specific document pipeline:
Product Concept → Target Audience → Design System → Architecture → Check All → Roadmap
Each document has its own stage with specific contracts — what must be produced, what tools are available, what validation is required. This ensures architectural work is systematic, not ad-hoc.
3. Mandatory Quality Checks
Every project includes a check_all.sh script that validates:
- Code quality (linting, formatting)
- Type safety
- Test coverage
- Build success
- Documentation updates
The agent runs this script as part of the audit stage. Tasks cannot complete until all checks pass. This is not optional — it's baked into the stage machine.
4. Tooling Policy per Stage
Each stage has explicit tool permissions:
clarification: read-only + Task Context write-backdata_collection: read-only + Task Context write-backdevelopment: full write accessaudit: read-only + test executionreport: read-only + report generation
This prevents accidental modifications during analysis and ensures the agent follows the process.
5. Knowledge Persistence
Decisions, hypotheses, negative knowledge ("this approach doesn't work because..."), and code references are stored in the Task Context — not lost in chat history. This knowledge:
- Persists across sessions
- Can be reviewed and edited
- Transfers to new tasks via Knowledge Migration
- Appears in handoff summaries for team collaboration
The Result
TAO·CODER produces traceable, auditable, high-quality code with:
- Clear specifications written before implementation
- Explicit acceptance criteria validated during audit
- Code references anchored to specific lines and git hashes
- Decisions documented with rationale
- Negative knowledge captured to avoid repeating mistakes
- Quality checks enforced before task completion
This is not "AI that writes code" — it's AI that develops software with a process.
Core Architecture
Role Modes
TAO·CODER switches between specialized role modes, each with its own stages, tool sets, and contracts:
| Mode |
Purpose |
Stages |
| Architect |
Architecture design, writing documents |
architecture_discussion → per-document stages (Product Concept, Target Audience, Design System, Architecture, Check All, Roadmap, Decisions, README_AI) → architecture_docs |
| Developer |
Development and refactoring |
clarification → data_collection → development → audit → report |
| Ops |
Operational tasks: deploy, monitor, rollback |
ops_diagnosis → ops_change → ops_validation → ops_escalation |
| Debug |
E2E testing, debugging and fixing bugs |
debug_setup → debug_environment → debug_execution → debug_fix → debug_validation |
| Task |
Codebase analysis, creating task specs in .md |
analysis → .md task files with code references |
| Free |
Quick edits with full Task Context, no stage machine |
stage machine disabled, Task Context active |
Mode transitions work differently depending on the pair:
- Architect → Developer and Ops → Developer: in-place switch on the same Task Context (same chat, no new task, conversation history preserved)
- Debug → Developer: controlled handoff via bundle export — creates a new Developer Task Context with merged knowledge from the Debug task
- Task → Developer: handoff via
taocoder_create_handoff — task .md files serve as source-of-truth
Structured Task Stages (Developer Mode)
Each role mode has its own stage pipeline. The pipeline shown below is specific to Developer mode — the primary mode for code development and refactoring.
Developer mode stages:
Clarification → Data Collection → Development → Audit → Report
- Clarification — The agent asks questions to understand your goal and writes it into the Task Context before touching code
- Data Collection — Reads files, searches patterns, explores the codebase; write tools are locked
- Development — Writes and edits code with full tool access
- Audit — Reviews changes, validates against acceptance criteria
- Report — Presents a clear summary of what was done
Each stage has strict tool permissions — write access is only granted during Development. This prevents accidental modifications during analysis.
Example: When you ask to refactor a module, the agent first clarifies requirements (What should change? What should stay the same?), then collects data (reads related files, understands dependencies), then implements changes, audits the result against your criteria, and finally reports what was done.
External Task Memory (Task Context Kernel)
TAO·CODER stores task context not in chat history, but in structured persistent storage on disk. The Task Context contains:
- Task specification and acceptance criteria
- Implementation plan with progress tracking
- Code references (anchored to specific lines and git hashes)
- Decisions and hypotheses
- Negative knowledge ("this approach doesn't work because...")
- Notes and handoff summaries for team collaboration
- Changes with diffs (anchored to workspace revisions)
Chat history remains bounded — no more than 10–15 recent turns. The update-cycle periodically extracts new facts from the dialogue tail and stores them in the Task Context, after which old turns are archived.
Why this matters: Traditional chat-based agents lose context as the conversation grows. TAO·CODER maintains a structured, searchable memory that persists across sessions and can be reviewed, edited, and transferred between tasks.
Task Context Cockpit
The Cockpit is a dedicated UI panel (Activity Bar) for managing the Task Context. It provides tabbed views:
Common tabs (available in all modes):
- Plan — Edit spec, acceptance criteria, implementation plan, exit criteria
- Memory — View/edit code references, changes, notes, hypotheses, decisions. Mark refs as stale. Hide/show notes. View execution log.
- Snapshots — Create, view, and rollback Task Context snapshots
- Metrics — Token usage, API costs, call counts (per stage and role mode)
Mode-specific tabs:
- Ops — Environment summary, services, log sources, health checks, rollback steps (visible only in Ops mode)
- Architect — Deliverables list, document metadata, diff review (visible only in Architect mode)
All Cockpit operations are scoped to the specific task — parallel background tasks each have their own Cockpit view.
Task Context Memory Management
TAO·CODER provides multiple mechanisms for managing task memory:
1. Agent-driven memory updates — The agent actively populates and edits the Task Context during work using dedicated tools: adding code references, recording decisions and hypotheses, marking negative knowledge, updating implementation plans, and tracking changes.
2. Update-cycle (automatic extraction) — A background mechanism that periodically extracts facts from the dialogue tail and merges them into the Task Context:
- At each LLM request, the system checks if enough new turns have accumulated
- If so, an update-cycle runs: the LLM analyzes recent turns and extracts facts (refs, decisions, hypotheses, negative knowledge)
- Extracted data is merged into the Task Context on disk
- Chat history is trimmed to bounded size
- The update-cycle also manages display: it can show/hide elements and reorder them based on relevance
- Budget GC manages the lifecycle: refs and changes are protected from eviction, only hypotheses and decisions are subject to budget-based garbage collection
3. Manual memory management via Cockpit — Users can directly interact with the Task Context through the Cockpit UI: edit spec and plans, mark references as stale, hide/show notes, reorder elements, create snapshots, and rollback to previous states.
This multi-layered approach ensures that memory is both automatically maintained (preventing context loss) and manually controllable (allowing precise adjustments when needed).
Flash Model Optimization
TAO·CODER is architecturally designed to work efficiently with fast, cost-effective flash models. This is achieved through:
Bounded Prompt Architecture — The context window never grows uncontrollably. The system maintains a fixed-size prompt with structured sections (Fixed Top Block + Chronological Feed + Static Block + Recent History), ensuring the model always has the most relevant information without being overwhelmed by history.
Structured Task Context — Instead of relying on the model to remember everything from a long conversation, the Task Context provides explicit, structured information about the current task, decisions made, and next steps.
Update-cycle Memory Extraction — Facts are automatically extracted from dialogue and stored in persistent memory, so the model doesn't need to process the entire conversation history.
Stage-based Tool Gating — The model only sees tools relevant to the current stage, reducing cognitive load and preventing accidental misuse.
Budget Management — Configurable hot budget and target budget tokens control the context size. Budget GC v3 protects refs and changes from eviction while managing hypotheses and decisions.
Result: TAO·CODER can solve complex tasks on flash models with the same quality as frontier models on simpler tasks, at a fraction of the cost and latency.
Metrics and Cost Tracking
TAO·CODER provides comprehensive real-time metrics for every task, enabling precise cost control and time tracking:
- Task duration — Real-time tracking of how long each task has been running
- API call count — Total number of API requests made during the task
- Tool call count — Number of tool invocations (file reads, writes, searches, terminal commands, etc.)
- Token usage — Input and output tokens per request and cumulative totals
- Cost tracking — API costs tracked per task, with breakdown by stage and role mode
All metrics are persisted in the task file on disk. This enables:
- Project-level cost estimation — Aggregate costs across all tasks to understand total project expenditure
- Time tracking — Review how much time was spent on each task and each stage
- Optimization insights — Identify which stages or role modes consume the most resources
- Budget control — Set limits and monitor spending in real-time
Metrics are visible in the Task Context Cockpit (Metrics tab) and can be reviewed at any time, even after the task is completed.
Parallel Task Execution
TAO·CODER supports working on multiple tasks simultaneously within a single VS Code window. This is a core architectural feature, not an afterthought.
How It Works
- Each task runs independently with its own Task Context, terminal sessions, and metrics
- Each task can use its own API provider and LLM model — you can run one task on a fast flash model while another uses a more capable model for complex reasoning
- The foreground task (the one you're chatting with) is separate from background tasks
- Background tasks continue executing but pause at approval points (file edits, command execution) waiting for your input
- Each task has its own role mode and stage — you can have a Developer task and an Ops task running in parallel
Running Tasks Management
- Running Tasks Activity Bar View — A dedicated panel in the VS Code Activity Bar shows all running tasks with live metrics (tokens, cost, API calls, duration)
- History Sidebar — The "Running" section in the history sidebar shows active tasks with green border, separate from completed history
- Per-task isolation — Terminal sessions, Task Context operations, and Cockpit views are scoped to individual tasks
- Close Task vs Move to History — "Close Task" terminates the task (terminal state), "Move to History" archives it (aborted state)
Example: You start a long-running refactoring task in Developer mode, then switch to a new Ops task to investigate a deployment issue. Both tasks run in parallel — the refactoring pauses at approval points while you handle the Ops task, then resumes when you return.
Knowledge Transfer Between Tasks
Knowledge Migration
When you complete a task and start a new one, TAO·CODER performs selective knowledge migration:
- The system analyzes the previous Task Context (refs, notes, decisions, negative knowledge)
- An LLM determines what is relevant to the new task
- Only relevant knowledge is transferred — not the full context
- The new task starts with a
previous_task_id link, enabling traceability
Handoff System
For cross-domain transfers (e.g., Debug finding a bug that requires architectural changes), TAO·CODER provides controlled handoff:
- Handoff Bundle — Exports spec, criteria, key refs, decisions, negative knowledge, and changes as references (not inline diffs)
- Auto-merge — When a new Developer task is created from a handoff, the bundle is automatically merged into the new Task Context
- Deduplication — If a ref/decision already exists in the new context, the duplicate is not added
- Handoff Summary — Upon task completion, a
handoff_summary.md is generated with the goal, result, key decisions, and changes
Recent Task Handoffs
When starting a new task, summaries of recent completed tasks are injected into the kernel as read-only context, so the agent knows what was done previously without re-processing full histories.
Quality and Precision
Code Quality
TAO·CODER maintains high code quality through:
- Stage-gated execution — Write access is only granted during the Development stage, after proper analysis and planning
- Audit stage — Every change is reviewed against acceptance criteria before completion
- Negative knowledge tracking — The agent remembers what doesn't work and why, preventing repeated mistakes
- Code reference anchoring — All references are tied to specific lines and git hashes, ensuring traceability
- Enforcement point — The system validates that the agent follows the implementation plan and flags mismatches
Example: When implementing a feature, the agent first writes acceptance criteria, then collects data about the codebase, then implements the feature, then audits the result against the criteria. If the audit fails, the agent fixes the issues before reporting completion.
Safety
TAO·CODER implements multiple safety mechanisms:
Command Safety Policy — Shell commands are deterministically classified into four levels:
safe — read-only or non-destructive commands (whitelist: ls, cat, npm install, git status, build tools, etc.)dangerous — destructive commands (blacklist: rm, sudo, dd, destructive git operations like git reset --hard)requires_approval — explicitly marked by user rulesunknown — no rule matched, requires manual approval
Classification priority: user blacklist → default blacklist → user require_approval → user whitelist → default whitelist → unknown. User-defined rules are stored in .taocoder/command_safety.json and extend the built-in patterns. Blacklist patterns are tested against the entire command (including chained segments) to catch dangerous operations anywhere in a pipeline.
Stage-based tool permissions — Each stage has strict tool access. Write tools (file edit, apply patch) require explicit confirmation (requireConfirm) on most stages. During Data Collection and Audit stages, write operations are locked or require approval.
Large file protection — write_to_file that rewrites an existing file larger than 300 lines, or writes a new file larger than 300 lines, forces manual approval regardless of auto-approval settings. This prevents accidental full-file overwrites of large files.
Compound Checkpoints — Workspace snapshots at each step capture workspace files + Task Context + task runtime/history + chat state, allowing full rollback to any previous point.
Crash Analyst — When the agent crashes (API failures, retry exhaustion), a separate LLM call classifies the error (terminal, correctable, recurring, agent_code_bug, prompt_bug) and determines recovery strategy.
JEV Decision Model — A probabilistic reasoning layer (Justification-Evidence-Verification) integrated at multiple execution points: custom mode stage hooks for deterministic stage transitions, terminal command safety guard that validates unknown commands before execution, and a dedicated agent tool (taocoder_jev_validate) for on-demand decision validation during task execution. This adds an additional safety layer without requiring manual approval for common development commands.
Example: If the agent tries to run rm -rf /tmp/build, the Command Safety Policy classifies it as dangerous and blocks it. If the agent tries to rewrite a 500-line file using write_to_file, the large file protection forces manual approval. If the agent crashes due to API failure, the Crash Analyst determines whether to retry, inject a corrective message, or escalate to the user.
Long-Distance Precision
TAO·CODER maintains precision over long execution distances (1000+ turns) through:
- Bounded prompt architecture — The context window never grows beyond a fixed size, preventing context loss
- Structured memory — The Task Context provides explicit, structured information about the current state
- Update-cycle extraction — Facts are automatically extracted and stored, preventing information loss
- Budget-based garbage collection — Old information is archived when it's no longer relevant, keeping the context focused. Refs and changes are protected from budget eviction.
- Prefix cache stability — System prompt sections that change every turn are moved to the kernel, preserving LLM prefix cache hit rate
Example: After 500 turns of development, the agent still knows exactly what the original requirements were, what decisions were made, and what the current state is. The Task Context provides this information explicitly, so the model doesn't need to remember it from the conversation history.
Task Context Budgets
TAO·CODER provides configurable budget controls for the Task Context:
- Hot Budget (tokens) — Upper limit for the hot part of the prompt (kernel + materialized snippets). Default: 50,000 tokens.
- Target Budget (tokens) — Target size after garbage collection. Default: 25,000 tokens.
- Max items — Configurable limits for snippets, lines per snippet, recent turns, and handoff summaries.
Budget settings are available in VS Code Settings (Prompt & Environment Settings) and per-workspace configuration.
- Stage transitions — Explicit promotion via
taocoder_set_stage with evidence tracking and exit criteria validation
- Handoff system — Controlled cross-domain transfers between tasks (Architect → Developer, Ops → Developer, Debug → Developer)
- Update-cycle — Automatic extraction of facts from dialogue into persistent memory
- Exit criteria — Each stage has a preset checklist; transition is only possible when all criteria are met
- Command Safety Policy — Deterministic classification of commands as safe/dangerous/unknown instead of LLM-gated approval
- Describe tool — On-demand tool help:
describe_tool(name) returns purpose, parameters, and example for any tool
- Task Context tools — Full set of tools for managing spec, plan, criteria, refs, notes, changes, snapshots, and handoffs
- JEV Decision Model — Probabilistic reasoning for stage transitions, command safety validation, and on-demand decision verification
How It Works
Tell TAO·CODER your goal — Describe what you want to achieve. Attach screenshots, error logs, or reference files. Use @/path/to/file.ts::START-END to reference specific line ranges.
TAO·CODER clarifies first — In the Clarification stage, it analyzes your codebase, reads README_AI.md (the project's living document), asks clarifying questions, and writes the spec and acceptance criteria into the Task Context.
Collects data — In the Data Collection stage, it reads files, searches patterns, and explores dependencies — without writing.
Implements changes — In the Development stage, it creates and edits files, runs commands, and uses tools.
Audits the result — In the Audit stage, it validates changes and runs tests.
Generates a report — In the Report stage, it presents a clear summary: what changed, why, and how to verify.
You stay in control — Send messages at any time, even while the agent is working — mid-turn message delivery ensures your input is captured. The agent pauses at approval points (file edits, dangerous commands) waiting for your decision.
API and Model Support
TAO·CODER supports a wide range of API providers. Here are some examples (the actual list is much larger):
- Anthropic — Claude family
- OpenAI — GPT family
- Google — Gemini family
- DeepSeek — DeepSeek family
- xAI — Grok family
- OpenRouter — Access 200+ models
- Alibaba — Qwen family (with custom base URL override)
- Any OpenAI-compatible API
- Local models via LM Studio or Ollama
The extension tracks total tokens and API usage cost for the entire task loop and individual requests, with breakdown by task stage and role mode. The architecture is optimized for flash models, allowing efficient work on cost-effective providers while maintaining high quality.
REST API Server Integration
TAO·CODER supports built-in REST API connectivity out of the box — no custom MCP configuration required. Define endpoints, authentication, and request schemas directly in the agent settings. Both REST API and MCP connections support OAuth authentication for secure integration with external services.
Reasoning Effort
TAO·CODER supports configurable reasoning effort levels, allowing you to control the depth of the model's analysis for each task.
Capabilities
Create and Edit Files
TAO·CODER creates and edits files directly in your editor, presenting a diff view of changes. You can modify or revert changes in the diff editor, or provide feedback in chat. It monitors linter/compiler errors (missing imports, syntax errors) and fixes them proactively.
All changes are recorded in your file's Timeline and in the Task Context Changes list with diffs anchored to workspace revisions.
Run Commands in Terminal
Execute commands directly in your terminal and receive output in real time. Install packages, run builds, deploy apps, manage databases, run tests — all while TAO·CODER adapts to your dev environment and toolchain.
For long-running processes (dev servers, builds), use "Proceed While Running" — TAO·CODER continues working and responds to new terminal output as it arrives.
Terminal sessions are isolated per task — parallel tasks each have their own terminal instances.
Web Search and Content Fetching
TAO·CODER can search the internet and fetch web content independently of any specific AI provider. Configure your preferred search provider (or use the built-in one) to enable:
- Web search — Find documentation, articles, code examples, and solutions
- Content fetching — Retrieve and convert web pages to markdown for processing
- Provider independence — Search capability works regardless of which LLM provider you use
This ensures TAO·CODER can always access up-to-date information from the web, not just what's in the training data.
TAO·CODER supports the Model Context Protocol (MCP) at the latest specification version, letting you extend its capabilities with custom tools:
- Two scopes: User (global, available in all projects) and Workspace (project-scoped, only available when the specific workspace is open)
- Move between scopes — "Move to Project" / "Move to Global" buttons in the UI
- Community and custom servers — Use community-made MCP servers or ask TAO·CODER to create custom tools tailored to your workflow
- OAuth authentication — MCP servers can use OAuth for secure integration with external services
Examples:
- "Add a tool that fetches Jira tickets" — Retrieve ticket ACs and put TAO·CODER to work
- "Add a tool that manages AWS EC2s" — Check metrics and scale instances
- "Add a tool that pulls the latest PagerDuty incidents" — Fix bugs in real time
TAO·CODER provides a dedicated manage_connections tool for managing both MCP and REST API connections directly from the agent. This tool enables:
- List connections — View all configured MCP and REST API connections
- Test connectivity — Verify that a connection is working correctly
- Add connections — Configure new MCP servers or REST API endpoints
- Update connections — Modify existing connection settings, headers, or environment variables
- Remove connections — Delete connections that are no longer needed
- Toggle settings — Enable/disable connections, change scope (user/workspace), adjust timeouts
- Set secrets — Securely store API keys and authentication tokens
Example workflows:
<!-- List all connections -->
<manage_connections>
<action>list</action>
</manage_connections>
<!-- Add a REST API connection with OpenAPI spec -->
<manage_connections>
<action>add</action>
<connection_type>rest</connection_type>
<connection_name>github_api</connection_name>
<spec_source>https://api.github.com/openapi.json</spec_source>
<headers>{"Authorization": "Bearer github_token"}</headers>
</manage_connections>
<!-- Set a secret value -->
<manage_connections>
<action>set_secret</action>
<key>github_token</key>
<purpose>GitHub API authentication</purpose>
</manage_connections>
Add Context
| Shortcut |
What it does |
@url |
Paste a URL — TAO·CODER fetches and converts to markdown for latest docs |
@problems |
Add workspace errors and warnings for TAO·CODER to fix |
@file |
Add a file's contents (with type-to-search) |
@folder |
Add an entire folder's files at once |
@/path/to/file.ts::START-END |
Reference specific line range in a file |
You can also use Explorer context actions: right-click files/folders in VS Code Explorer → "Add file to TaoCoder" / "Add folder to TaoCoder".
Quote selection: Select text in any message → "Quote selection" inserts it into chat with > prefix.
Checkpoints: Compare and Restore
As TAO·CODER works through a task, it takes workspace snapshots at each step. TAO·CODER uses compound checkpoints that capture:
- Workspace files (via shadow-git)
- Task Context state
- Task runtime and history
- Chat current pointer
Restore operations return your entire workspace and aligned task history to the selected point. This lets you safely explore different approaches without worrying about state getting out of sync.
Snapshot management:
- Auto-prune: snapshots older than 7 days or more than 50 per task are automatically cleaned up
- Protected snapshots: snapshots linked to active chat checkpoints are never deleted without explicit force
- Audit log: all snapshot operations (create/delete/prune/rollback) are recorded
Memory Management
For long-running sessions (600–800+ turns), TAO·CODER implements intelligent memory management:
- VirtualList rendering — Efficient rendering of long message histories
- Message pruning — Old messages are automatically archived beyond the visible limit
- Checkpoint commits — Configurable limit on active checkpoint commits (default 100)
- Command output flooding prevention — At most one
command_output message exists at any time, preventing terminal output from flooding the chat
Secrets Management
TAO·CODER implements a zero-trust secrets architecture where API keys and sensitive credentials never reach the agent context. The system automatically extracts, stores, and injects secrets without exposing them to the LLM or chat history.
How It Works
Automatic Extraction — When you configure MCP servers or REST API connections with plaintext secrets (API keys, tokens), TAO·CODER automatically detects and extracts them from environment variables, headers, and connection parameters.
Secure Storage — Extracted secrets are immediately saved to VS Code's SecretStorage (encrypted, OS-level keychain integration). The original plaintext values are replaced with placeholders in the configuration:
{
"env": {
"API_KEY": "{{SECRET:myApiKey}}"
}
}
Deterministic Injection — When executing REST API calls, MCP server commands, or any script that references a placeholder, the secretsResolver deterministically replaces {{SECRET:keyName}} with the actual value from SecretStorage at execution time only. The real value never appears in:
- Agent context or task messages
- Chat history or logs
- Webview state or UI
- Task Context or checkpoints
Direct Secret Input — Users can also add secrets directly through the secret_input chat window. The TaoCoderSecretSubmitHandler transports values straight from the input to SecretStorage, bypassing all intermediate layers.
Security Guarantees
- Agent never sees secrets — LLM prompts contain only placeholder strings like
{{SECRET:github_token}}
- No leakage in logs — Error messages and logs show only key names, never values
- Checkpoint safety — Task Context stores only placeholder references, not actual secret values
- Webview isolation — The UI displays masked values; real secrets never reach the browser context
Managing Secrets
Use the manage_connections tool to view and manage secrets:
<!-- List all connections and their secret keys -->
<manage_connections>
<action>list</action>
</manage_connections>
<!-- Set or update a secret value -->
<manage_connections>
<action>set_secret</action>
<key>github_token</key>
<purpose>GitHub API authentication</purpose>
</manage_connections>
Secrets are scoped per connection and can be user-level (global) or workspace-level (project-specific).
Feedback and Support
We welcome your feedback! If you encounter issues, have suggestions, or want to share your experience, please reach out through the VS Code Marketplace or contact us via our website.
License
TAO·CODER is globally free to use for standard development workflows. All built-in role modes (Architect, Developer, Ops, Debug, Task, Free), scheduled task execution, and core features are available without any cost.
Premium features (require registration and subscription):
- Custom TAO·MODES — Create and run your own role modes with custom stage pipelines for specialized workflows
- Mobile access — Monitor and control tasks from the mobile PWA app (coming soon)
All premium features share a single subscription tier. Standard modes, scheduled tasks, and all other core functionality remain free forever.
Custom Role Modes and Stages
TAO·CODER includes a powerful customization system: create your own role modes with custom stage pipelines tailored to specific domains and workflows. This extends TAO·CODER beyond coding into any structured task domain.
Example: News Research and Content Creation Mode
You can create a custom mode for news collection, analysis, and article preparation:
news_research mode stages:
→ topic_research (web search, source collection)
→ analysis (compare sources, extract key facts)
→ draft (write article/post)
→ style_review (check tone, voice, target audience)
→ fact_check (verify claims against sources)
→ final_edit (polish and prepare for publication)
Example: Server Log Analysis and Ticket Creation Mode
You can create a custom mode for connecting to servers, analyzing logs, and creating detailed bug tickets with code-level root cause analysis:
log_analyst mode stages:
→ connect (SSH to server, verify access)
→ collect_logs (tail/grep recent logs, filter by severity)
→ analyze_errors (identify error patterns, stack traces, timestamps)
→ trace_code (search codebase for related code paths, understand call chains)
→ root_cause_analysis (correlate logs with code, identify the exact lines causing issues)
→ create_ticket (generate detailed bug report with code references, log excerpts, reproduction steps)
This mode can run on a schedule (e.g., every hour) to proactively detect and report issues before users notice them.
Each custom mode has:
- Its own stage pipeline with tool permissions per stage
- Custom stage prompts that guide the agent's behavior
- Stage-specific contracts (what the agent must produce at each stage)
- Full Task Context integration (spec, plan, refs, notes)
This means you can use TAO·CODER for content creation, research, analysis, documentation — any workflow that benefits from structured stages and persistent memory.
Manage Tasks from Your Phone (Coming Soon)
A future mobile PWA app will let you monitor and control TAO·CODER tasks from anywhere. Set up scheduled tasks, check progress, review results — all from your phone.
Imagine: you set up a log_analyst mode to run every hour, checking your servers for errors and creating tickets automatically. You go for a walk, sit in a meeting, or grab lunch — and the agent keeps working. You check your phone and see: 3 new tickets created, 2 issues resolved, 1 needs your attention.
That's the vision: structured autonomous work that you orchestrate, not babysit.
Scheduled Task Execution
TAO·CODER supports running tasks on a schedule. Set up recurring or one-time scheduled tasks that execute automatically:
- Cron-based scheduling — Define tasks that run at specific times or intervals
- Background execution — Scheduled tasks run in the background with their own Task Context
- Notification — Get notified when a scheduled task completes or encounters issues
- Cross-mode task creation — An agent finishing work in one mode can create and launch a new task in a different mode
Autonomous Development Cycles
When you combine custom role modes with scheduled execution, you can build fully autonomous development, debugging, and business process cycles with predictable, reliable results:
- Multi-stage quality gates — Add audit, review, and verification stages to ensure high-quality output
- Cross-mode orchestration — An agent completing work in Developer mode can automatically create a task in Ops mode for deployment, or in Debug mode for testing
- Scheduled autonomous workflows — Run these cycles on a schedule (hourly, daily, weekly) for continuous autonomous operation
Example autonomous cycle:
- Scheduled task runs
log_analyst mode every hour
- Agent detects an error pattern, creates a ticket
- Agent automatically creates a new task in
developer mode with the bug context
- Developer agent fixes the issue, runs tests, creates a pull request
- Agent creates an
ops task to deploy the fix to staging
- Ops agent validates the deployment, reports success
This creates a self-healing system where issues are detected, diagnosed, fixed, and deployed — all autonomously, with full traceability through Task Context and handoff summaries.
Privacy and Data
Your privacy matters. TAO·CODER is designed with privacy in mind:
- No metrics collection — We do not collect usage metrics, telemetry, or analytics
- Direct API calls — All LLM API traffic goes directly from your machine to the provider of your choice. Your code, prompts, and data never pass through our servers
- Local storage — Task Context, checkpoints, and all task data are stored locally on your machine
- You control your data — Everything stays in your workspace; nothing is sent to us
