Skip to main content

​
What Are AI Agents?

AI agents in Tesslate Studio are autonomous coding assistants powered by large language models. They do more than generate text; they can read your files, write code, execute shell commands, manage containers, and plan multi-step tasks. Each agent has a system prompt that defines its behavior, a set of tools it can call, and a model that powers its reasoning. Think of agents as programmers you can chat with. Describe what you want in natural language, and the agent figures out which tools to use, which files to modify, and how to get it done.

Natural Language Input

Describe features, fixes, or changes in plain English

Tool Calling

Agents read files, write code, run commands, and more

Multiple Agent Types

Four architectures optimized for different tasks

Marketplace Ecosystem

Discover, install, and publish specialized agents

​
The Four Agent Types

Tesslate Studio provides four agent architectures. Each inherits from a shared AbstractAgent base class and can be created through the factory pattern.

StreamAgent

Single LLM call, fast streaming output
  • No tool calling; extracts code blocks from the response
  • Ideal for quick code generation and prototyping
  • Lowest token usage and cost

IterativeAgent

Multi-step loop with full tool support
  • Think, Act, Observe loop with JSON-based tool calls
  • Automatic error recovery and retry
  • Great for file operations, shell commands, and multi-file changes

ReActAgent

Explicit Reasoning + Acting pattern
  • Mandatory THOUGHT section before every action
  • Structured observations after each tool execution
  • Best for debugging, architecture decisions, and auditable reasoning

TesslateAgent

Full-featured production agent
  • Native LLM function calling (no JSON-in-text parsing)
  • Subagent spawning for focused subtasks
  • Trajectory recording for debugging and analytics
  • Context compaction for long conversations
  • Planning mode for structured plans before execution
Most users start with TesslateAgent (the default) or IterativeAgent for general development. See Agent Types for a deep comparison.

​
How Agents Work

​
Agent Lifecycle

Every agent follows this high-level lifecycle:
1

Initialization

The agent factory loads the agent configuration from the marketplace database, creates a scoped tool registry, substitutes system prompt markers (like {project_name} and {mode_instructions}), and instantiates the correct agent class.
2

Context Building

Before the first LLM call, the system assembles context: environment info, file listings, git status, chat history, and your message. This context helps the agent understand your project.
3

Execution Loop

The agent sends messages to the LLM and receives a response. If the response contains tool calls, the agent executes them (respecting edit mode permissions), collects results, and feeds them back for the next iteration. This loop continues until the task is complete.
4

Completion

The agent signals completion when it detects a TASK_COMPLETE marker, runs out of tool calls, or reaches resource limits. Final results stream back to the chat interface.

​
Architecture Overview

Agent System
  AbstractAgent (base class)
    |
    |-- StreamAgent        (single-pass, code block extraction)
    |-- IterativeAgent     (multi-step, JSON tool calls)
    |-- ReActAgent         (explicit reasoning, structured observations)
    |-- TesslateAgent      (native function calling, subagents, trajectory)
    |
    +-- ToolRegistry       (central tool registration and execution)
          |
          |-- File Ops     (read_file, write_file, patch_file, multi_edit)
          |-- Shell Ops    (bash_exec, shell_open, shell_exec, shell_close)
          |-- Project Ops  (get_project_info)
          |-- Planning Ops (todo_read, todo_write)
          |-- Web Ops      (web_fetch)
          |-- Graph Ops    (9 container management tools)

​
Agent Tools

Tools are the actions agents can perform. Each tool has a name, description, parameter schema, and an async executor function. The ToolRegistry manages registration, lookup, and execution with edit mode control.
ToolDescription
read_fileRead the contents of any file in the project
write_fileCreate a new file or overwrite an existing one
patch_fileSurgical search/replace edit with fuzzy matching
multi_editApply multiple patches to a single file atomically

​
Edit Modes

Edit modes control how much autonomy an agent has when executing tools. You can switch modes at any time using the mode button in the chat input.
Dangerous tools (file writes, shell commands) require your approval before executing. Read operations proceed without interruption.When a tool needs approval, you see three options:
  • Allow Once: Approve this single operation
  • Allow All: Approve this tool type for the rest of the session
  • Stop: Cancel the operation
In Allow All Edits mode, the agent can modify files and run commands without asking. Use this mode only when you are comfortable with fully autonomous operation.

​
Quick Comparison

FeatureStreamAgentIterativeAgentReActAgentTesslateAgent
Tool SupportNo (code blocks only)Yes (full registry)Yes (full registry)Yes (native function calling)
Execution LoopSingle LLM callThink, Act, Observe loopThought, Action, ObservationNative tool loop with trajectory
Error RecoveryNoneAutomatic retryAutomatic retryRetry + context compaction
Reasoning StyleImplicitOptionalMandatory (explicit)Flexible
Planning ModeNoNoNoYes
SubagentsNoNoNoYes
SpeedFastestModerateModerateModerate
Token UsageLowMediumHighMedium
Best ForQuick UI generationGeneral development tasksDebugging, architectureFull-featured production work

​
Agent Marketplace

The Marketplace is where you discover, install, and publish agents:
  • Official Agents: Built and maintained by Tesslate (Stream Builder, Tesslate Agent, React Component Builder, and more)
  • Community Agents: Created by users (Code Analyzer, Doc Writer, Refactoring Assistant, Test Generator, and more)
  • Specialized Agents: Focused on specific frameworks, languages, or tasks
Agents can be free or paid, open-source or closed-source. Open-source agents can be forked and customized.

​
Next Steps

Agent Types

Deep dive into each agent architecture

Using Agents

Practical guide to chatting with agents

Customizing Agents

Create and configure custom agents

Agent Marketplace

Browse and install specialized agents