TAO·CODER — Installation and Usage Guide

Table of Contents

1. What is TAO·CODER and how is it different from other AI agents
2. Installation
   • 2.1. Installing VS Code / VS Codium
   • 2.2. Installing the TAO·CODER extension
   • 2.3. Choosing a model and provider
   • 2.4. The Task Context panel
   • 2.5. Language
   • 2.6. Web search provider (optional)
3. Work methodology
   • 3.1. Role modes
   • 3.2. Stage pipeline
   • 3.3. Key documents
   • 3.4. Starting a task
4. Advanced features
   • 4.1. TAO·MODES — custom work modes
   • 4.2. MCP servers — external tools
   • 4.3. REST API — connecting to external APIs
   • 4.4. Rules and Workflows
   • 4.5. Scheduled execution (Schedule)
5. Practical tips and troubleshooting

---

1. What is TAO·CODER and how is it different from other AI agents

Artificial intelligence changed software development. TAO·CODER changed development with artificial intelligence.

Working with AI agents used to feel like a game of roulette: context would fill up, the agent would lose track of the task, and token costs would skyrocket. A single project consumed more nerves than code.

TAO·CODER is a coding agent for VS Code / VS Codium. It is not a chatbot that generates code on demand, but a full-fledged development tool with a built-in methodology. Thanks to its architecture — bounded context, stage pipeline, managed memory — it allows a single developer to run multiple complete projects in parallel, faster, cheaper, and more reliably than ever before.

You only pay for the tokens of the provider you choose yourself. The extension is free.

No telemetry. TAO·CODER does not collect logs, code, prompts, or any other data from your computer. Everything runs locally: project files, prompts, Task Context — everything stays with you. The only thing that leaves your machine is API requests to your chosen LLM provider (the tokens you pay for).

Key differences from other AI agents

Bounded context. Regular agents linearly accumulate conversation history — each new step prepends previous messages to the prompt. Eventually the model’s context window fills up, the agent loses focus, and work quality drops. TAO·CODER externalizes task memory into a structured Task Context on disk. Only the essentials go into the prompt: current stage, task specification, relevant code snippets, and the last few conversation turns. History does not grow indefinitely, the model stays focused, and costs are predictable.

Stage pipeline. Instead of a free-form “ask and get an answer” mode, TAO·CODER runs tasks through formal stages: clarification → data collection → development → audit → report. Each stage restricts which tools are available. For example, write tools are locked during data collection — the model cannot accidentally modify a file while studying the code. This ensures a transparent, controlled process.

Update cycle. TAO·CODER has two complementary mechanisms for moving information from the conversation into long-term memory. First, the agent actively and consciously records findings, code, and decisions into Task Context as it works, using dedicated tools (taocoder_add_relevant_code_ref, taocoder_add_decision_human_confirmed, and others). Second, an update cycle runs periodically: when enough new conversation turns have accumulated, the model automatically analyzes recent messages, extracts facts, decisions, and findings, and saves them to Task Context, after which older messages are archived. These two mechanisms complement each other and together keep the history bounded.

check_all.sh — quality gate. By default, TAO·CODER creates a check_all.sh script that runs a full suite of checks: typecheck, linter, tests, documentation validation. The script prevents the agent from submitting a task with bad code. Before completing a task, the agent must run check_all.sh and fix everything until it’s green.

Cost-effectiveness on flash models. Thanks to bounded prompts and the update cycle, TAO·CODER handles complex tasks efficiently even on cheap flash models (DeepSeek V4 Flash, Gemini Flash, Claude Haiku, and others). Context does not balloon, so there is no reason to overpay for frontier models on routine tasks.

• A completed project phase: $1–5 ($5 is the max).
• A medium project (e.g., a custom CRM with HTML newsletters and forms, 100–150k LOC): ~$200 in tokens (100K LOC of production code with deployment, excluding VPS cost; DeepSeek 4 Flash + DeepSeek 4 Pro combined).
• If you need more speed and quality — DeepSeek V4 Pro, Qwen family models, or previous-generation GPT models at reasonable prices.
• Frontier models for routine development are overkill. They are only needed for complex architectural decisions or particularly tricky bugs.

Naming: TAO·CODER (with a middle dot). In code and identifiers, camelCase is used: TaoCoder. In text, documentation, and UI — only TAO·CODER.

---

2. Installation

2.1. Installing VS Code / VS Codium

If VS Code is not yet installed, download it from code.visualstudio.com.

TAO·CODER also works on VS Codium (the open-source build of VS Code). Important: the latest version of the extension is always available on VS Code. VS Codium updates may be delayed.

2.2. Installing the TAO·CODER extension

Open VS Code and go to the Extensions tab (the squares icon in the left panel, or Cmd+Shift+X). Search for TAO·CODER (with the dot) and click Install.

After installation, Trust Developer (confirm the developer). The extension will install and its icon will appear in the Activity Bar on the far left.

Moving the panel to the right (recommended). By default, TAO·CODER opens in the left panel. For convenience, move it to the right:

1. Right-click the TAO·CODER icon in the Activity Bar (the vertical row of icons on the left).
2. Select Move to Right Side Bar.

2.3. Choosing a model and provider

1. Click the gear icon (Settings) in the top bar of the TAO·CODER chat window.
2. Select LLM Provider — the provider you will work through. List of supported providers (all current models of each are available):
   • DeepSeek (recommended: DeepSeek V4 Flash for routine tasks, V4 Pro if you need more speed and quality)
   • Anthropic (Claude)
   • OpenAI (GPT)
   • Google Gemini
   • Qwen
   • AWS Bedrock, Azure OpenAI, GCP Vertex AI
   • OpenRouter (access to 200+ models)
   • Cerebras, Groq, Mistral
   • Local models via LM Studio or Ollama
   • Any OpenAI-compatible API
3. I recommend starting with DeepSeek V4 Flash — the best price/quality ratio for most tasks.
4. If the provider requires an API key — click the registration link, sign up, get your key, and top up your balance.
5. Enter the key in the API Key field.
6. Select a model and click Add to Favorites. You can add multiple models and switch between them during work.
7. It is recommended to add 2–3 providers as a fallback in case one fails.
8. Save your settings with the Done button.

2.4. The Task Context Panel (Cockpit)

Task Context is the agent’s managed memory. It lives in a separate panel, not in the chat history.

How to open it:

1. In the central editor area (where TAO·CODER is open), look at the top of the panel.
2. There is a split-screen button — click it to split the central area into 2 parts (e.g., editor and panel).
3. On the right side, click the menu with three dots (...) and select Task Context, or click the Task Context button located right above the message input field.

The Task Context panel will appear (labeled in English). This is the cockpit — the task’s dashboard. It displays: task specification, execution plan, relevant code references, decisions, notes, stages, snapshots.

2.5. Language

In the TAO·CODER settings, find the Preferred Language parameter. This is the language the agent will use to respond to you in chat and to reason. Select your preferred language.

2.6. Web search provider (optional)

If you need the agent to search the internet:

1. In the settings, find the Web Search Provider section.
2. Select Brave (recommended) — you can get a free key at brave.com/search.
3. Enter the key.

After that, the agent will have access to web_search and web_fetch tools.

---

3. Work Methodology

TAO·CODER includes an AI-assisted development methodology that differs from the classical approach. The agent and methodology are the result of a year of intensive development with AI agents (roughly 2 million lines of code in completed projects).

Don’t jump straight into Developer mode. Start with Architect mode.

3.1. Role modes

TAO·CODER has five built-in modes, each with its own stages, tools, and contracts. The mode switcher is located right above the message input field. Next to it is a Mode Help button — click it to see a short description of each mode.

Mode	Purpose	Stages
Architect	Architecture design, writing documentation	discussion → docs
Developer	Development and refactoring	clarification → data_collection → development → audit → (rework → audit) → report
Ops	Operations: deployment, monitoring, rollback	diagnosis → change → validation → escalation
Debug	E2E testing, debugging	setup → environment → execution → fix → validation
Free	Quick fixes without formal stages	stage machine disabled

The mode is selected when a task is first created. It can be switched within a task by pausing it (Pause), but this is not recommended: each mode maintains its own Task Context, and switching may disrupt context.

In addition to built-in modes, TAO·CODER supports custom modes through the TAO·MODES system — see section 4.1 for details.

3.2. Stage pipeline

In Developer mode, a task goes through the following stages:

1. Clarification The agent asks questions to understand what needs to be done. It does not touch code — only clarifies.

2. Data Collection Studies the code: reads files, looks for dependencies, explores the architecture. Write tools are locked — file modification is impossible.

3. Development Writes code, edits files, runs commands. Full access to all tools.

4. Audit Checks changes against acceptance criteria, runs tests, check_all.sh.

5. Rework — if audit found issues. If checks fail, the agent returns to rework, fixes the issues, and runs audit again. The audit → rework → audit cycle repeats until everything passes.

6. Report Summarizes what was done, what was changed, and how to verify. Files and commands are unavailable — only the report.

Stage transitions are initiated by the agent via the taocoder_set_stage tool. The agent must provide a reason and evidence references confirming that the current stage’s criteria are met.

3.3. Key documents

README_AI.md — the project bible for AI. This is a mandatory document that TAO·CODER creates in the project root. It contains all the information the agent needs to quickly understand the project: description, architecture, repository structure, how to run it, and how to check quality. The agent reads this file at the start of each task and updates it throughout development.

CHECK_ALL.md and check_all.sh — quality gate. CHECK_ALL.md describes the check script. check_all.sh is the executable script that runs typecheck, linter, tests, and documentation validation. The agent cannot complete a task while check_all.sh is not green. This prevents shipping broken code.

Roadmap. The agent creates a Roadmap so that each phase fits into a single development cycle (one task). Phases are sequential and independent of each other.

3.4. Starting a task

If the project is new:

1. Switch to Architect mode.
2. Describe to the agent what you want to build, who your target audience is, and what design you want.
3. The agent will ask clarifying questions, then write documents phase by phase: PRODUCT_CONCEPT → TARGET_AUDIENCE → ARCHITECTURE → DESIGN_SYSTEM → README_AI → ROADMAP → CHECK_ALL.
4. Read the documents. If needed, ask the agent to explain and correct. Don’t hesitate to clarify unclear points or ask for the most logical solutions.

If the project already exists:

1. Switch to Architect mode.
2. Ask the agent to audit the project and fill in the documents based on what already exists.

When all documents are ready and you are satisfied with them:

(A) Starting a task in Developer:

1. Click + (New Session) and select Developer mode.
2. Open the Roadmap (located in the project root or in the docs/ folder).
3. Find Phase 1, select its text — a lightbulb will appear (action suggestion).
4. Click the lightbulb and select Add to TaoCoder.
5. A link to the phase will appear in the chat. Write “Running Phase 1”.
6. The agent will explore the project and ask clarifying questions. If everything is fine, confirm the criteria it has defined.
7. Work begins: the agent will collect data, write findings to memory, develop, run audits, rework, and run tests. At the end, it will return with a report.
8. Repeat step (A) for each phase of the Roadmap until everything is complete.

Ops — deployment to a server. Ops mode will tell you what it needs for deployment (locally or on a VPS).

Debug — E2E testing. Debug mode is for developing and running full E2E tests on a locally running project.

Free — quick fixes. Free mode is for small fixes and tasks where the full stage pipeline is not needed. Task Context memory is still maintained, but stages are disabled.

---

4. Advanced features

Once you’re comfortable with the basics, TAO·CODER offers powerful tools for automation and extending the agent’s capabilities.

4.1. TAO·MODES — custom work modes

TAO·MODES is a system of custom modes that lets you create your own “work profile” for the agent. If the built-in modes (Architect, Developer, Ops, Debug, Free) don’t cover your scenario — you can create your own.

What is a mode? A mode is a set of stages, prompts, and rules that define how the agent works. Each mode consists of:

• System prompt — instructions for the agent (a .md file)
• Stages — a sequence of steps, each with its own prompt, available tools, and exit criteria
• Flags — which capabilities are available (MCP, Rules, required secrets, etc.)

Examples of custom modes:

• Code Review — stages analyze → report → fix for automated code review
• Documentation — stages extract → structure → write → validate for documentation generation
• Autonomous Cyclic — a mode for scheduled execution with cyclic task processing
• Cross-Mode Task Creation — an agent in one mode creates tasks that trigger other modes

How to create your own mode:

The simplest way is to use the built-in Mode Builder mode:

1. In the mode switcher (below the message input field), select Mode Builder.
2. Describe to the agent what mode you need (e.g., “Create a mode for automated PR review”).
3. The agent will guide you through 4 stages:
   • clarification — understand what mode to create
   • design — design the mode structure
   • implementation — create the mode files
   • validation — verify the mode works correctly

Where modes are stored:

Scope	Path	Purpose
Global	~/.taocoder/modes/	Available across all projects
Project	<project root>/.taocoder/modes/	Specific to this project

Project modes take priority over global ones — if a mode with the same id exists in both scopes, the project mode is used.

Managing modes: Click the TAO·MODES (🧭) button in the right navigation panel. The mode management screen opens with tabs:

• Modes — list of all modes, selection, copying, hiding
• Editor — create and edit modes manually
• Presets — manage tool presets
• Info — built-in TAO·MODES documentation

Switching modes in chat: At the bottom of the chat, next to the input field, there is a mode dropdown. Click it to select a custom mode for the current task. When a custom mode is selected, its name is displayed instead of “TAO·MODES”.

4.2. MCP servers — external tools

MCP (Model Context Protocol) is a protocol for connecting external tools and resources to the agent. Through MCP, you can give the agent access to databases, third-party service APIs, specialized tools — anything that has an MCP server.

Why do you need this? TAO·CODER’s built-in tools cover file operations, terminal, and browser. But if you need the agent to work with PostgreSQL, send messages to Slack, manage Jira tickets, or use specialized libraries — MCP servers extend the agent’s capabilities without modifying its code.

How to connect an MCP server:

1. Click the MCP (🖥) button in the right navigation panel.
2. Click + Add Server.
3. Choose the server type:

Local server (runs on your machine):

• Specify the launch command (e.g., node, python, npx)
• Command arguments
• Environment variables (including API keys)

Remote server (connects via HTTP):

• Server URL
• Transport: streamableHttp (default) or sse (Server-Sent Events)
• Headers (e.g., Authorization: Bearer <token>)

4. Save the configuration. The server will appear in the list with a status indicator (connected / disconnected / error).

Configuration example (local server):

{
  "mcpServers": {
    "my-database": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"],
      "env": {}
    }
  }
}

Configuration example (remote server):

{
  "mcpServers": {
    "slack-tools": {
      "url": "https://mcp.example.com/slack",
      "transportType": "streamableHttp",
      "headers": { "Authorization": "Bearer xoxb-your-token" }
    }
  }
}

Security: Secrets (API keys) are stored in VS Code’s secure storage and never written to disk in plain text. Use {{SECRET:KEY}} placeholders in your configuration — values are injected automatically at runtime.

MCP button indicator: Red number — there are disconnected servers; normal number — all servers are connected.

4.3. REST API — connecting to external APIs

In addition to MCP, TAO·CODER supports direct REST API connections. This is useful when a service doesn’t have an MCP server but has a regular HTTP API.

How to connect a REST API:

1. Click the REST API (🌐) button in the right navigation panel.
2. Click + Add Server.
3. Fill in:
   • Server Name — a unique name for the server
   • Base URL — the API base URL (e.g., https://api.example.com)
   • Headers — authorization headers (e.g., Authorization: Bearer <token>)
4. Add endpoints:
   • Name — endpoint name (e.g., get-users)
   • Method — HTTP method (GET, POST, PUT, DELETE)
   • Path — path (e.g., /users)
   • Description — description for the agent

Import from OpenAPI (Swagger): If the API has an OpenAPI specification, you can import all endpoints automatically:

1. In the editor, select Import from OpenAPI Spec.
2. Paste the JSON/YAML specification or provide a URL.
3. The specification is validated, and all endpoints are added automatically.

How the agent uses REST API: When the agent needs to call an endpoint, it uses the use_rest_api tool, specifying the server name and endpoint name. The response is displayed in the chat as an expandable block.

Configuration example:

{
  "restApiServers": {
    "github-api": {
      "baseUrl": "https://api.github.com",
      "headers": { "Authorization": "Bearer {{SECRET:githubToken}}" },
      "endpoints": [
        {
          "name": "list-repos",
          "method": "GET",
          "path": "/user/repos",
          "description": "List current user's repositories"
        }
      ]
    }
  }
}

4.4. Rules and Workflows

Rules are files with instructions that the agent considers during work. They allow you to set context, constraints, and preferences without repeating them in every message.

Where rules are stored:

Type	Path	Purpose
Global	~/.taocoderules/	Applied to all projects
Project	<project root>/.taocoderules/	Specific to this project

Rule formats from various tools are supported: Cline (.md files), Cursor, Windsurf, and Agents. Each rule can be toggled on or off.

Workflows are step-by-step sequences for repetitive tasks. For example, deploying a service, submitting a PR, generating a report. To invoke a workflow, type /workflow-name in the chat.

Workflows are stored in:

• Globally: ~/.taocoderules/workflows/
• Per project: <project root>/.taocoderules/workflows/

Hooks are scripts that run at specific points in the agent’s lifecycle (before/after tool calls). Stored in ~/.taocoderules/hooks/ and <project root>/.taocoderules/hooks/.

Skills are reusable instruction sets that the agent activates on demand via the use_skill tool when a task matches a skill’s description.

Management: Click the Rules (📖) button in the right navigation panel. A screen opens with tabs: Rules, Workflows, Hooks, Skills — for each content type.

4.5. Scheduled execution (Schedule)

TAO·CODER supports automatic task execution on a schedule (cron). This is a powerful tool for automating routine operations: nightly builds, periodic code audits, regular report generation.

How to set up a schedule:

1. Click the Schedule (📅) button in the bottom group of the right navigation panel.
2. Click + Create Schedule.
3. Fill in:
   • Name — schedule name (e.g., “Nightly build”)
   • Cron expression — when to run (e.g., 0 2 * * * — every day at 2:00 AM)
   • Mode — which mode to run in (e.g., Developer)
   • Task — what to do (task text for the agent)
4. Save.

How it works:

• Scheduled tasks run in autonomous mode — the agent works without confirmation prompts. The task header shows a purple “Autonomous run (scheduled)” badge.
• If VS Code was closed or the computer was asleep when a scheduled run was due — upon next launch, a dialog appears offering: Run now, Skip, or Reschedule.

Cron expression examples:

• 0 2 * * * — every day at 2:00 AM
• 0 */6 * * * — every 6 hours
• 0 9 * * 1-5 — at 9:00 AM on weekdays
• 0 0 1 * * — on the 1st of every month at midnight

Schedule button indicator: The number shows how many active schedules there are.

---

5. Practical tips and troubleshooting

Tips

1. Don’t start with Developer. Even for an existing project, start with Architect. It will save you money and nerves: the agent will first understand the project, document everything, and then work meaningfully.

2. Don’t hesitate to clarify. The agent is not a mind reader. If something is unclear or you want it done differently — ask. Especially in Architect mode.

3. Watch the Task Context. In the Task Context panel (Cockpit), you can see which stages have been completed, the current TODO, and what is in the memory sections (relevant code, decisions, notes). It also displays statistics: time elapsed, steps taken, tokens spent. The system does not allow Task Context to be empty or incomplete — it controls itself. There is essentially nothing to regulate.

4. Use multiple providers. If one provider goes down (error, limit, outage), switch to another. Add models from at least two providers to Favorites.

5. Create a repository early. It is better to create a GitHub/GitLab repository and link it to your local folder right away. The agent in Free mode can help with this.

6. Save on models. For routine development, flash models (DeepSeek V4 Flash, Gemini Flash) are sufficient. Keep frontier models (Claude, GPT-5, and others) for complex architecture and tricky bugs.

7. Don’t expect instant results. TAO·CODER works thoroughly: it collects data, writes documentation, runs audits. Quality takes time. Don’t worry — it may take a while, but it’s still inexpensive and very reliable.

8. Use TAO·MODES for recurring scenarios. If you regularly do similar tasks (PR review, documentation generation, deployment) — create a custom mode through Mode Builder. It will save time and ensure consistent quality.

9. Autonomous mode for routine tasks. Enable the Autonomous toggle (in the right navigation panel) to let the agent work without confirming every action. Convenient for tasks where you trust the agent.

Troubleshooting

The agent is stuck / stopped responding. First try pausing the task (Pause), then click Continue. If pause also fails — close VS Code, reopen it, select the task from history, and click Continue. This is a known issue — a legacy of the agent not being built from scratch. Problems are being fixed gradually.

The agent asks for manual confirmation. TAO·CODER cannot fully rewrite large files — this is a security limitation. Some commands (e.g., restoring files from a remote repository) are permanently forbidden. This is normal.

The Task Context panel does not appear. Make sure the central area is split into 2 parts (click the split-screen button), then in the ... menu select Task Context, or click the Task Context button right above the message input field.

Cannot find TAO·CODER in the Marketplace. The extension may be delayed on VS Codium. Use the VS Code Marketplace to install the latest version.

web_search does not work. Check that the Web Search Provider is configured in settings (e.g., Brave) and that the API key is entered and saved.

MCP server won’t connect. Check: the launch command and arguments (for local servers), URL and headers (for remote servers). Click the MCP (🖥) button — the red indicator will show which servers are disconnected. Try reconnecting via the test button.

---

The agent’s code name — “The Stickler”. Because it truly sees things through to the end: documentation, tests, audit, report — nothing gets skipped. Don’t be put off by how thoroughly it works — it actually delivers results.