Building AI Agents from Scratch in Rust in 2026

Chatbot (single turn):
  User: "What's the weather in Paris?"
  LLM: "I don't have real-time weather data."
 
Agent (multi-step):
  User: "What's the weather in Paris?"
  LLM: [decides to call get_weather tool]
  Tool: {"city": "Paris", "temp": 18, "conditions": "Cloudy"}
  LLM: "It's currently 18°C and cloudy in Paris."

Goal → [LLM] → Tool calls? ──yes──→ [Execute tools] → [LLM with results] → Done?
                     │                                                         │
                     └─────────────────no──────────────────────────────────→ Final answer

[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::collections::HashMap;
 
// Tool definitions : sent to the LLM as JSON schema
fn get_tools() -> Vec<Value> {
    vec![
        json!({
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Get current weather for a city",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "City name"}
                    },
                    "required": ["city"]
                }
            }
        }),
        json!({
            "type": "function",
            "function": {
                "name": "search_web",
                "description": "Search the web for information",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "query": {"type": "string", "description": "Search query"}
                    },
                    "required": ["query"]
                }
            }
        }),
    ]
}
 
// Tool implementations
fn execute_tool(name: &str, args: &Value) -> String {
    match name {
        "get_weather" => {
            let city = args["city"].as_str().unwrap_or("unknown");
            // Real implementation would call a weather API
            format!("{{'city': '{}', 'temperature': 22, 'conditions': 'Sunny'}}", city)
        }
        "search_web" => {
            let query = args["query"].as_str().unwrap_or("");
            // Real implementation would call a search API
            format!("Search results for '{}': [result 1, result 2, result 3]", query)
        }
        _ => format!("Unknown tool: {}", name),
    }
}
 
#[derive(Serialize, Deserialize)]
struct Message {
    role: String,
    content: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tool_calls: Option<Vec<Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tool_call_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    name: Option<String>,
}
 
async fn run_agent(goal: &str) -> Result<String, Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let api_key = std::env::var("OPENAI_API_KEY")?;
 
    let mut messages: Vec<Value> = vec![
        json!({"role": "system", "content": "You are a helpful assistant. Use tools when needed."}),
        json!({"role": "user", "content": goal}),
    ];
 
    let max_iterations = 10;  // Safety limit
 
    for iteration in 0..max_iterations {
        // Call the LLM
        let response = client
            .post("https://api.openai.com/v1/chat/completions")
            .bearer_auth(&api_key)
            .json(&json!({
                "model": "gpt-4o",
                "messages": messages,
                "tools": get_tools(),
                "tool_choice": "auto",
            }))
            .send()
            .await?
            .json::<Value>()
            .await?;
 
        let choice = &response["choices"][0];
        let message = &choice["message"];
        let finish_reason = choice["finish_reason"].as_str().unwrap_or("");
 
        // Add the assistant's response to history
        messages.push(message.clone());
 
        // If no tool calls : we're done
        if finish_reason == "stop" || message["tool_calls"].is_null() {
            let content = message["content"].as_str().unwrap_or("").to_string();
            return Ok(content);
        }
 
        // Execute tool calls
        let tool_calls = message["tool_calls"].as_array().unwrap();
 
        for tool_call in tool_calls {
            let tool_call_id = tool_call["id"].as_str().unwrap_or("");
            let function_name = tool_call["function"]["name"].as_str().unwrap_or("");
            let args_str = tool_call["function"]["arguments"].as_str().unwrap_or("{}");
            let args: Value = serde_json::from_str(args_str)?;
 
            println!("[Iteration {}] Calling tool: {}({:?})", iteration + 1, function_name, args);
 
            let result = execute_tool(function_name, &args);
 
            // Add tool result to message history
            messages.push(json!({
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": result,
            }));
        }
    }
 
    Err("Agent exceeded maximum iterations".into())
}
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let answer = run_agent("What's the weather in Tokyo and what are the top tourist attractions there?").await?;
    println!("Agent answer:\n{}", answer);
    Ok(())
}

use rig::{completion::Prompt, providers::openai, tool::Tool};
use serde::{Deserialize, Serialize};
use serde_json::json;
 
#[derive(Deserialize)]
struct WeatherArgs { city: String }
 
#[derive(Serialize)]
struct WeatherResult { city: String, temp_celsius: i32, conditions: String }
 
struct WeatherTool;
 
impl Tool for WeatherTool {
    const NAME: &'static str = "get_weather";
    type Error = String;
    type Args = WeatherArgs;
    type Output = WeatherResult;
 
    fn definition(&self, _name: String) -> rig::tool::ToolDefinition {
        rig::tool::ToolDefinition {
            name: Self::NAME.to_string(),
            description: "Get current weather for a city".to_string(),
            parameters: json!({
                "type": "object",
                "properties": { "city": {"type": "string"} },
                "required": ["city"]
            }),
        }
    }
 
    async fn call(&self, args: WeatherArgs) -> Result<WeatherResult, String> {
        Ok(WeatherResult {
            city: args.city,
            temp_celsius: 22,
            conditions: "Sunny".to_string(),
        })
    }
}
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let openai = openai::Client::from_env();
 
    let agent = openai
        .agent(openai::GPT_4O)
        .preamble("You are a helpful assistant. Use tools when needed to answer questions.")
        .tool(WeatherTool)
        .build();
 
    let answer = agent
        .prompt("What's the weather in Paris and Tokyo?")
        .await?;
 
    println!("{}", answer);
    Ok(())
}

use std::collections::VecDeque;
 
// Short-term memory: sliding window conversation history
struct AgentMemory {
    history: VecDeque<(String, String)>,  // (role, content) pairs
    max_turns: usize,
}
 
impl AgentMemory {
    fn new(max_turns: usize) -> Self {
        Self { history: VecDeque::new(), max_turns }
    }
 
    fn add(&mut self, role: &str, content: &str) {
        if self.history.len() >= self.max_turns * 2 {
            self.history.pop_front();
            self.history.pop_front();
        }
        self.history.push_back((role.to_string(), content.to_string()));
    }
 
    fn to_messages(&self) -> Vec<serde_json::Value> {
        self.history.iter()
            .map(|(role, content)| serde_json::json!({
                "role": role,
                "content": content
            }))
            .collect()
    }
}

use tracing::{info, warn, instrument};
 
#[instrument(skip(api_key), fields(model = "gpt-4o", iteration))]
async fn run_agent_iteration(
    messages: &[Value],
    api_key: &str,
    iteration: usize,
) -> Result<Value, Box<dyn std::error::Error>> {
    info!(message_count = messages.len(), "Starting LLM call");
 
    let response = /* ... LLM API call ... */ todo!();
 
    info!(
        finish_reason = response["choices"][0]["finish_reason"].as_str(),
        "LLM responded"
    );
 
    Ok(response)
}
 
// In your tool execution:
fn execute_tool_with_tracing(name: &str, args: &Value) -> String {
    let span = tracing::info_span!("tool_call", tool = name);
    let _guard = span.enter();
 
    info!(args = %args, "Executing tool");
    let result = execute_tool(name, args);
    info!(result_len = result.len(), "Tool completed");
 
    result
}

Production deployment topology:
─────────────────────────────────────────────────────────
Client request
    → API Gateway (rate limiting, auth)
    → Rust Agent Service (single binary, ~10MB Docker image)
        → OpenAI/Anthropic API (LLM calls)
        → Tool services (weather API, search API, database)
        → Redis (conversation memory store)
    → Response