AI Capabilities

TatsuCode is an agentic coding assistant. Unlike simple chat interfaces, it can take autonomous actions to accomplish tasks — reading files, making edits, running commands, and more.

What "Agentic" Means

When you ask TatsuCode to "fix the bug in the login function," it doesn't just suggest code. It:

Reads the relevant files to understand the code
Analyzes the problem and identifies the fix
Proposes changes with a diff preview
Applies the changes (with your approval)
Verifies by running tests or linting

You give the goal; TatsuCode figures out the steps.

Core Capabilities

File Operations

TatsuCode can read, write, and edit files in your project:

Reading:

> What does src/auth/login.ts do?
> Show me the database configuration
> Read the package.json

TatsuCode reads text files, images (for visual analysis), PDFs, and Jupyter notebooks.

You can also drag files and folders directly into the input area (from inside or outside the project). If an item cannot be fully read, TatsuCode can still keep its path as context.

Writing:

> Create a new utility file for date formatting
> Add a README to this project

New files are created with your approval.

Editing:

> Add error handling to the fetchUser function
> Fix the typo on line 42 of config.ts
> Replace all console.log with logger.debug

TatsuCode uses intelligent diff-based editing:

Finds the exact location to change
Applies minimal modifications
Preserves formatting and style
Shows you the diff before applying

Office Documents (DOCX/XLSX/PPTX/CSV)

TatsuCode can work with Office documents directly using markdown-style workflows.

> Read this quarterly-report.docx and summarize key risks
> Update Q3-revenue.xlsx with the new totals
> Replace "Draft" with "Final" in the slide deck
> Create a new project-update.docx from this outline

You can use it for:

Reading Word, Excel, PowerPoint, and CSV files into structured text
Writing new .docx, .xlsx, .pptx files from markdown content
Editing existing Office files in-place (targeted content updates)

Code Analysis

Find symbols and definitions:

> Where is the UserService class defined?
> Find all functions that handle authentication

Analyze dependencies:

> What imports does this file use?
> Which files depend on utils/helpers.ts?

Lint and check for errors:

> Check this project for TypeScript errors
> Are there any issues with the Python code?

TatsuCode integrates with:

TypeScript/JavaScript (via Biome)
Python (via Ruff)
C# (via Roslyn)
And many more languages

Terminal Commands

TatsuCode can run commands in your terminal:

> Run the tests
> Build the project
> Start the dev server
> Install the missing dependency

Commands require your approval before execution. You can:

Allow once
Allow for the session
Always allow (for trusted commands)

Web Search & Research

Search for documentation and solutions:

> Search for React 19 migration guide
> What are the best practices for JWT authentication?

Fetch and analyze web pages:

> Read the OpenAI API documentation
> What does the Prisma docs say about transactions?

YouTube Video Analysis

TatsuCode supports multiple YouTube analysis modes depending on your goal.

> Get transcript only for this YouTube video
> Analyze this YouTube tutorial and extract the setup steps
> Do a deeper video analysis and summarize mistakes to avoid

Common modes:

Transcript mode — text + metadata only (fast, low token usage)
Direct video analysis — for vision-capable routes that can process video/audio
Deeper isolated analysis — delegated analysis flow for longer/complex videos

Browser Automation

For web development, TatsuCode includes a private DevBrowser:

> Open your local app URL in the browser
> Click the login button
> Fill the email field with test@example.com
> Take a screenshot
> Check for console errors

The DevBrowser is completely isolated from your system browser — no shared cookies, credentials, or browsing history.

Screenshot Analysis

TatsuCode can capture and analyze screenshots:

> Take a screenshot of the browser
> Capture the current window

Combined with vision-capable modern models (Claude, GPT, Gemini families), this enables:

Visual debugging of UI issues
Comparing before/after designs
Analyzing error dialogs
Understanding mockups and diagrams

File History & Undo

All file edits during a session are tracked:

> Undo the last edit to main.py
> Revert config.json to its original state
> Show me the edit history for this session

You can:

Revert to any previous state
View all files edited this session
Search through edit history
Restore original content

Sessions are also resilient to crashes and power loss — long sessions are saved frequently and restore cleanly.

Image Generation, Editing, and Annotations

> Generate a pixel-art potion bottle sprite sheet
> Take @img-02 and turn the sky into a dramatic sunset
> Crop @img-04 to just the error dialog and zoom in

A complete image workflow — generate new images, edit existing ones with masks and reference images, browse a unified gallery (/image-gallery), and mark up images directly in chat. Works across OpenAI Direct, Google Direct, and OpenRouter image models. See Images.

PDF Analysis (Native PDF Reader Sub-Agent)

> Summarize this PDF and describe the diagram on page 7
> Extract all the figures from this report

A dedicated PDF Reader sub-agent handles PDFs through models with native PDF input and renders pages reliably — text and charts, diagrams, scanned content, equations, signatures. No Poppler dependency. Auto-activates whenever a PDF could contain visual content. See Task Agents.

Claude Code (Claude Pro / Max / Team / Enterprise)

If you have a Claude subscription, you can use Claude Code directly in TatsuCode without API billing. Sign in via /connect → Claude Agent, and the Claude Code models appear in /models. Streaming, durable file diffs, session restore, Cross-Agent Relay handoffs to other providers — all first-class. See Claude Code.

Layered Memory and Lossless Compact

Three durable instruction tiers — global (~/.tatsu/AGENTS.md), project (repo-level AGENTS.md and friends), and repo-local override (.agents/AGENTS.local.md) — applied in order so each refines or overrides the broader layer. A separate continuity layer keeps long sessions coherent across compactions and session restores. See Layered Memory.

Local Vision Models

Local providers like Ollama and LM Studio now have automatic vision detection — multimodal models (Gemma 4, Qwen-VL, etc.) work out of the box without manual capability flags, with self-healing retry if the local server starts after TatsuCode.

Runtime Hooks (Skills and Plugins)

Skills and plugins can declare interest in lifecycle events — turn start, tool execution, model switch, compaction, session restore — and observe them as they happen. See Runtime Hooks.

Agent Skills & Reusable Workflows

TatsuCode supports reusable skill workflows for specialized tasks.

Common use cases:

Deep debugging and architecture analysis
Consistent release checklists
Team-standard code review flow
Repeatable migration playbooks

Use:

/skills

To learn when to use built-in skills like deep-think and skill-editor, see Agent Skills.

Multi-Step Workflows

TatsuCode excels at complex, multi-step tasks:

Bug Fixing

> I'm getting "undefined is not a function" in auth.js. 
  Find and fix the issue.

TatsuCode will:

Read the file and related code
Trace the error source
Identify the root cause
Propose and apply the fix
Optionally run tests to verify

Feature Development

> Add a password reset feature to the auth module

TatsuCode will:

Analyze existing auth code
Plan the implementation
Create necessary files
Integrate with existing code
Add tests if appropriate

Refactoring

> Refactor the UserController to use dependency injection

TatsuCode will:

Understand the current structure
Identify what needs to change
Make coordinated edits across files
Preserve existing functionality

Code Review

> Review the changes in src/components/ for security issues

TatsuCode will:

Read the relevant files
Analyze for common vulnerabilities
Report findings with explanations
Optionally fix issues

Limitations

What TatsuCode Can't Do

Access your browser's cookies or credentials (DevBrowser is isolated)
Edit system or Windows files that could damage the operating system
Make destructive changes to your git repository without approval
Run destructive terminal commands without approval (unless you've allowed them)

Note: TatsuCode includes guardrails to prevent harmful actions, but AI models can occasionally find unexpected workarounds. We recommend monitoring activity during sensitive operations and reviewing changes before approving them.

When to Guide It

TatsuCode works best when you:

Be specific — "Fix the null check in getUserById" beats "fix the bug"
Provide context — Mention the framework, conventions, or constraints
Break down big tasks — Large requests may need multiple steps
Review changes — Always check diffs before approving

Best Practices

Let TatsuCode Choose Tools

Instead of prescribing how:

# Less effective
> Read main.py, then edit line 42 to fix the bug

# More effective  
> Fix the authentication bug in main.py

Iterate Naturally

> Add input validation to the form
> Actually, also add client-side validation
> And show error messages below each field

Use Context from Files

Reference files with @:

> Looking at @auth.ts and @user.ts, how should I implement session management?

Monitor Long Sessions

For long conversations:

Use /usage to check context consumption
Use /compact to compress when needed
Start /new sessions for unrelated work

Next Steps

Tools Reference — Detailed tool documentation
Agent Skills — Specialized reusable workflows
DevBrowser — Browser automation details
File History — Undo and versioning
Commands — All slash commands