Latitude Agents are an advanced prompt type that enables AI models to operate autonomously, breaking down complex tasks, using tools, and reasoning through multiple steps until a final goal is achieved. Unlike simple prompts or even Chains which follow predefined steps, Agents can dynamically decide their next action based on the context and available tools.
When you finish reading this page you can read our take on Anthropic’s building agents article

​
Defining an Agent

To turn a prompt into an Agent, simply add type: agent to its configuration block: 
---
provider: openai
model: gpt-4o
type: agent
---

Plan and execute the steps needed to research and write
a short blog post about the benefits of using Latitude Agents.

​
How the Agent Loop Works

When an Agent prompt is run:
  1. Goal Understanding: The agent analyzes the initial prompt to understand the overall task or goal.
  2. Planning (Implicit): It internally plans the first step needed to move towards the goal.
  3. Action: It decides whether to: a. Call a Tool: If it needs external information or functionality, it requests a tool call. b. Generate Response: If it has enough information or needs to ask a clarifying question, it generates text.
  4. Observation: If a tool was called, it receives the tool’s response.
  5. Reasoning: Based on the goal, previous steps, and new observations (tool responses), it reasons about the next action needed.
  6. Repeat: Steps 3-5 repeat until the agent determines the original goal is fully accomplished.
  7. Final Answer: The agent provides the final result.
This loop allows the agent to adapt its strategy, handle errors, and utilize tools effectively.

​
Using Tools Within Agents

Agents become truly powerful when combined with Tools. Provide the agent with a set of relevant tools, and it will decide which ones to use and when. 
---
provider: openai
model: gpt-4o
type: agent
tools:
  - latitude/search
  - get_weather
  - get_location_id

  # Tool definitions...
  - get_weather:
      # ... definition
  - get_location_id:
      # ... definition
---

Find the current weather for {{ location_name }}.
In this example, the agent might:
  1. Realize it needs a location ID for get_weather.
  2. Call get_location_id with location_name.
  3. Receive the location_id.
  4. Call get_weather with the obtained location_id.
  5. Receive the weather data.
  6. Formulate and return the final answer to the user.

​
Defining the Final Output (Schema)

You can guide the agent’s final output by specifying a response schema using JSON Schema: 
---
provider: openai
model: gpt-4o
type: agent
tools:
  - latitude/search
schema:
  type: object
  properties:
    summary:
      type: string
      description: A concise summary of the findings.
    key_points:
      type: array
      items:
        type: string
      description: A list of key bullet points.
  required: [summary, key_points]
---

Research the main features of the Vercel AI SDK and provide a summary and key bullet points.
The agent will work towards fulfilling the task and then structure its final response according to the schema.

​
Predefined Steps

While agents operate autonomously, you can provide initial instructions or force specific actions using <step> tags. The agent will execute these predefined steps first before entering its autonomous loop. 
---
# ... agent config ...
---

<step>
  First, search for recent news about AI advancements.
</step>

<step>
  Then, identify the top 3 trends mentioned.
</step>

Now, write a short analysis comparing these trends.

​
Limiting Agent Iterations

To prevent agents from running indefinitely (e.g., getting stuck in loops), you can limit the maximum number of steps (tool calls + LLM responses) using the maxSteps configuration option (default: 20, max: 150). 
---
# ... agent config ...
maxSteps: 10 # Limit the agent to 10 steps
---
If the limit is reached before the goal is completed, the agent run will terminate with an error.

​
Running Agents

Agents are run just like any other prompt using the API or SDKs. The response will typically be a stream of events detailing the agent’s thought process, tool calls, and final answer.

​
Subagents

You can make any prompt have access to other agents in your project by using the agents configuration option. This allows you to create a hierarchy of agents, where tasks are delegated to subagents with specific responsibilities. 
---
provider: openai
model: gpt-4o
agents:
 - path/to/another-agent
---
The main prompt will have access to running the subagent prompt as if it was a tool. This allows you to structure complex tasks into smaller, manageable sub-tasks performed by different agents.

​
Next Steps