Build AI in Rails.
Agents are controllers.

@Agents are controllers

Actions, before_action, params. Run now, or later on Active Job.

class TranslationAgent < ApplicationAgent
  generate_with :openai, model: "gpt-4o-mini"
  before_action :load_glossary

  def translate
    prompt   # renders translate.md.erb
  end
end

TranslationAgent.with(text: "Hello", locale: "ja")
                .translate.generate_now
TranslationAgent.with(text: "Hello", locale: "ja")
                .translate.generate_later   # Active Job

*Action Prompt

Prompts are views. ERB, partials and layouts, plus an instructions file per agent.

app/views/agents/translation/
  instructions.md      # the system prompt
  translate.md.erb     # the user turn
  translate.json       # a response schema, if any

<%# translate.md.erb %>
Translate into <%= params[:locale] %>, keeping the tone:

<%= params[:text] %>

>>Any provider

OpenAI, Anthropic, Gemini, Bedrock, Azure, Ollama, OpenRouter, Requesty, DeepSeek, RubyLLM. One line to switch.

generate_with :anthropic, model: "claude-sonnet-4-5"
generate_with :openai,    model: "gpt-4o-mini"
generate_with :gemini,    model: "gemini-2.5-flash"
generate_with :ollama,    model: "qwen3:8b"
generate_with :deepseek,  model: "deepseek-flash"
generate_with :ruby_llm,  model: "mistral-large-latest"

# or per environment, in config/active_agent.yml

[]Tools from your schema

Bounded, allowlisted read tools generated from a model, scoped to whoever is asking.

class TicketTools < ActiveAgent::SchemaTools
  model Ticket

  filterable :status, :assignee_id, :opened_on
  returns    :id, :subject, :status, :opened_on

  scope_by_policy   # TicketPolicy::Scope, per caller
end

TicketTools.tool_names
# => ["find_tickets", "count_tickets", "get_ticket"]

{}MCP servers

Remote url: or local command: servers. Native where the provider supports it, bridged everywhere else.

def research
  prompt(
    params[:question],
    mcps: [
      { name: "github",
        url: "https://api.githubcopilot.com/mcp/",
        authorization: ENV["GITHUB_TOKEN"] },
      { name: "files",
        command: "mcp-server-filesystem",
        args: [ Rails.root.to_s ] }
    ]
  )
end

->Delegation

Another agent as a tool, under a declared schema and a cost and latency budget.

class ClassifierAgent < ApplicationAgent
  delegation :classify, description: "Classify a ticket" do
    string :body, required: true
    returns { string :category, enum: %w[billing bug account] }
  end

  def classify(body:) = prompt(message: body)
end

class TriageAgent < ApplicationAgent
  delegate_to ClassifierAgent, budget: { max_calls: 1 }
end

@activeagent

The framework. Agents, actions and prompt templates; ten providers; tools, schema tools, MCP servers and delegation; structured output and streaming; evaluations and telemetry built in.

->actionagent

The dashboard, as a mountable Rails engine. Traces, metrics, interactions and evaluations; the agent builder, versions and the Run Agent workbench; your agents served as an MCP server. Prebuilt assets, no JavaScript build in your app.

#solid_agent

Persistence as models you own. Conversation context, agent-curated long-term memory, durable runs with progress events, tool result caching, model pricing, and portable agent manifests (.agent.md, dotprompt, CrewAI).

~activeagents-telemetry

Tracing for Ruby apps that call models without the framework. The RubyLLM adapter reports every chat turn as a trace on the same wire format, to a mounted dashboard or the platform. Bodies are sent only when you say so.