> ## Documentation Index
> Fetch the complete documentation index at: https://docs.triform.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Triton Overview

> Your AI assistant for building, editing, and debugging Triform Projects

## What is Triton?

Triton is Triform's built-in AI assistant that helps you build, modify, and debug your Projects through natural conversation. Instead of manually wiring nodes and writing code from scratch, you can describe what you want and Triton handles the implementation.

## Where to find Triton

Triton lives in the **Chat Panel** at the bottom of the **Builder workspace**. Click the chat icon or press `Cmd+K` (Mac) / `Ctrl+K` (Windows) to open it.

> note: Triton is for **building** your systems. To **use** your agents conversationally, switch to the **Chat workspace** from the Top Bar.

## What Triton can do

### Build new components

* **Create Projects** — *"Build me a Project for processing customer feedback"*
* **Generate Agents** — *"Create an Agent that classifies support tickets by urgency"*
* **Write Actions** — *"Make an Action that fetches data from the GitHub API"*
* **Design Flows** — *"Build a Flow that validates input, processes it, and sends notifications"*

### Modify existing work

* **Update code** — *"Add error handling to this Action"*
* **Restructure Flows** — *"Convert this sequential Flow to run Actions in parallel"*
* **Refine prompts** — *"Make this Agent more concise in its responses"*
* **Add features** — *"Add logging to all Actions in this Project"*

### Debug and troubleshoot

* **Explain errors** — *"Why did this execution fail?"*
* **Analyze behavior** — *"Why is this Agent not using the tools?"*
* **Optimize performance** — *"How can I make this Flow faster?"*
* **Find issues** — *"What's causing the timeout in this Action?"*

### Answer questions

* **Explain concepts** — *"How do Project Variables work?"*
* **Provide guidance** — *"What's the best way to structure a multi-step workflow?"*
* **Review code** — *"Is this Action following best practices?"*
* **Suggest improvements** — *"How can I improve this Agent's prompt?"*

## How to use Triton effectively

### Be specific

❌ **Vague:** *"Fix this"*\
✅ **Specific:** *"Add retry logic with exponential backoff to the API call in this Action"*

❌ **Vague:** *"Make it better"*\
✅ **Specific:** *"Optimize this Flow to process items in parallel instead of sequentially"*

### Provide context

When asking about errors or issues:

* Mention which component (Action, Agent, Flow)
* Describe what you expected vs. what happened
* Share relevant error messages
* Indicate when it works vs. when it fails

**Example:**\
*"The `fetch_news` Action works in testing but times out in production when processing more than 10 sources. Can you add batching?"*

### Break down complex requests

Instead of: *"Build a complete customer service system with ticket routing, sentiment analysis, auto-responses, and escalation"*

Try:

1. *"Create an Agent that classifies support tickets"*
2. *"Add sentiment analysis to the ticket classifier"*
3. *"Build a Flow that routes tickets based on classification"*
4. *"Add auto-response Action for common issues"*
5. *"Implement escalation logic for high-priority tickets"*

### Iterate and refine

Triton's first attempt might not be perfect. Provide feedback:

* *"That's close, but make the prompt more formal"*
* *"Good, now add error handling"*
* *"The logic works, but can you add logging?"*

## Triton's workflow

When you make a request, Triton:

1. **Analyzes** your current Project context
2. **Plans** the implementation approach
3. **Executes** the changes (creates/modifies components)
4. **Validates** the changes work together
5. **Explains** what was done and next steps

You'll see this happening in real-time in the Chat Panel.

## Triton's capabilities

### Code generation

Triton writes production-ready Python code for Actions:

* Proper error handling
* Type hints
* Logging
* Input validation
* Idiomatic patterns

### Graph understanding

Triton comprehends your Flow structures:

* Identifies bottlenecks
* Suggests optimizations
* Maintains data flow integrity
* Preserves connections when editing

### Prompt engineering

For Agents, Triton crafts effective prompts:

* Clear instructions
* Example patterns
* Tool usage guidance
* Error handling behavior

### Best practices

Triton follows Triform conventions:

* Naming conventions
* Project structure
* Security patterns
* Performance optimizations

## Limitations

While Triton is powerful, it:

* **Can't** execute Projects (use Execute panel for that)
* **Can't** access external systems (unless via your Actions)
* **Can't** modify deployed Projects (must redeploy after changes)
* **May** need multiple iterations for complex requests
* **Works best** with clear, specific instructions

## Tips for success

> **Start with "why"** — Explain the goal, not just the task. "I need to process 1000 items quickly" gives better context than "make this parallel"

> **Review changes** — Always check what Triton built before executing. It's your code!

> **Use it for learning** — Ask "How does this work?" or "Why did you do it this way?"

> **Iterate incrementally** — Build and test small pieces, then expand

> **Combine with Execute** — Use Triton to build, Execute panel to test

## Common patterns

### Create-test-refine loop

1. *"Create an Action that calls the weather API"*
2. Test it with Execute panel
3. *"Add caching to reduce API calls"*
4. Test again
5. *"Add error handling for network failures"*
6. Test edge cases
7. Deploy

### Explore-then-modify

1. *"What does this Project do?"*
2. *"Why is this Agent using 3 tools?"*
3. *"How can I make it faster?"*
4. *"Implement that optimization"*

### Debug-fix-verify

1. *"Why did execution #123 fail?"*
2. *"Fix the null pointer error in the validation Action"*
3. Re-run execution
4. *"Add tests to prevent this in the future"*

## Next steps

Continue exploring the Triton documentation to learn about:

* Defining Projects conversationally
* Building components step-by-step
* Editing and modifying existing work

## Examples

See Triton in action:

### Example 1: Build a sentiment analyzer

**You:** *"Create an Agent that analyzes sentiment of customer reviews"*

**Triton:** Creates:

* Agent with appropriate system prompt
* Input schema for review text
* Output schema for sentiment (positive/negative/neutral) and confidence
* Example test case

### Example 2: Optimize a slow Flow

**You:** *"This Flow is taking 30 seconds to process 100 items. How can I speed it up?"*

**Triton:**

* Analyzes the Flow structure
* Identifies sequential bottleneck
* Suggests parallel processing
* Implements batching with 10 items per batch
* Estimates new processing time (\~5 seconds)

### Example 3: Fix an error

**You:** *"Execution failed with 'KeyError: source\_url'. What's wrong?"*

**Triton:**

* Reviews the execution logs
* Identifies the Action expecting `source_url` but receiving `url`
* Suggests either: (1) fix the input mapping, or (2) update the Action to accept `url`
* Implements your chosen solution

## Feedback

Triton improves based on usage. If you encounter issues or have suggestions:

* Report via [Support](/support/report-a-bug)
* Share patterns that work well
* Request new capabilities

Your feedback shapes Triton's evolution!