active_agent_ai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f8e59ee6101735d458933d0da5e9eb6e8f3bd39df7071398d7249e6f890cea6
+  data.tar.gz: e99fc40d871ccedc862e0bea72527189bdc172ae3b69f7c7fec41e5a3ddf2776
+SHA512:
+  metadata.gz: 95549528b0c33c08f926796aa726e8a961da50e13659813e7594c061078dabf932e1ba32e65a90a19679b43df1ebdd985dee5d307a67c3e0c6f7d550dee6d31d
+  data.tar.gz: 4a6cd7a3ff52d930d796e70886e50deec8903a05468cf59df4a6d8c886490bfe1bde3b1db63dc73005131cf39618029aa140623cdafcd7dde71ed9444d4bb794

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction: including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDINGRem, BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# active_agent 🤖
+
+[![Gem Version](https://badge.fury.io/rb/active_agent_ai.svg)](https://badge.fury.io/rb/active_agent_ai)
+[![GEM Downloads](https://img.shields.io/gem/dt/active_agent_ai.svg)](https://rubygems.org/gems/active_agent_ai)
+[![CI Status](https://github.com/aditya-8108/active_agent/actions/workflows/ci.yml/badge.svg)](https://github.com/aditya-8108/active_agent/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**The Native Multi-Agent AI Framework for Ruby & Rails.**
+
+Inspired by Python's [CrewAI](https://github.com/crewAIInc/crewAI) and [Microsoft AutoGen](https://github.com/microsoft/autogen), [`active_agent`](https://github.com/aditya-8108/active_agent) provides a clean, idiomatic Ruby DSL to orchestrate teams of autonomous AI agents with roles, backstories, tools, tasks, and multi-provider LLMs.
+
+---
+
+## Key Features 🚀
+
+- 👥 **Autonomous Agent Teams**: Define specialized personas (`Agent`) with goals, backstories, and assigned capabilities.
+- 🛠️ **Custom Executable Tools**: Agents dynamically select and execute custom Ruby tools (`ActiveAgent::Tool`) to perform real-world tasks (Web Search, Database Queries, API calls).
+- 📋 **Task Orchestration**: Assign discrete objectives (`Task`) with expected outputs and context passing across workflow steps.
+- 🌐 **Multi-Provider LLM Adapters**: Built-in support for **OpenAI** (`gpt-4o`), **Anthropic Claude** (`claude-3-5-sonnet`), **Google Gemini** (`gemini-1.5-flash`), and **Ollama (Local AI)**.
+- ⚡ **Sequential & Parallel Processes**: Run agent teams in sequential pipelines where outputs pass from step to step.
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_agent_ai'
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+---
+
+## Quickstart Example
+
+Define tools, agents, tasks, and kick off your agent team in 100% native Ruby:
+
+```ruby
+require 'active_agent'
+
+# 1. Define a Custom Executable Tool
+class WebSearchTool < ActiveAgent::Tool
+  description "Searches the web for latest software benchmarks and language features"
+  param :query, type: :string, desc: "Search query", required: true
+
+  def perform(query:)
+    # Execute actual search or API call here
+    "Ruby 3.4 introduces Prism parser by default and 20% YJIT performance gains."
+  end
+end
+
+# 2. Define Specialized AI Agents
+researcher = ActiveAgent::Agent.new(
+  role: "Senior Tech Researcher",
+  goal: "Find cutting-edge developments in Ruby & Rails",
+  backstory: "An expert language analyst with 10 years of compiler and AST experience.",
+  tools: [WebSearchTool],
+  provider: :openai # or :claude, :gemini, :ollama
+)
+
+writer = ActiveAgent::Agent.new(
+  role: "Technical Journalist",
+  goal: "Draft engaging tech articles from technical research reports",
+  backstory: "A skilled writer capable of explaining complex software benchmarks simply.",
+  provider: :openai
+)
+
+# 3. Define Tasks
+research_task = ActiveAgent::Task.new(
+  description: "Research Ruby 3.4 JIT benchmarks and Prism parser updates",
+  expected_output: "Detailed technical report with benchmarks",
+  agent: researcher
+)
+
+write_task = ActiveAgent::Task.new(
+  description: "Write a high-converting blog post based on the research findings",
+  expected_output: "Formatted Markdown article ready for publication",
+  agent: writer
+)
+
+# 4. Assemble and Kickoff Team
+team = ActiveAgent::Team.new(
+  agents: [researcher, writer],
+  tasks: [research_task, write_task],
+  process: :sequential
+)
+
+result = team.kickoff
+puts result
+```
+
+---
+
+## Multi-Provider Support
+
+`active_agent` seamlessly works with all top LLM providers:
+
+```ruby
+# OpenAI
+agent = ActiveAgent::Agent.new(role: "Coder", goal: "Refactor", provider: :openai, model: "gpt-4o")
+
+# Anthropic Claude
+agent = ActiveAgent::Agent.new(role: "Analyst", goal: "Audit", provider: :claude, model: "claude-3-5-sonnet-20241022")
+
+# Google Gemini
+agent = ActiveAgent::Agent.new(role: "Data Engine", goal: "Parse", provider: :gemini, model: "gemini-1.5-flash")
+
+# Ollama (100% Local AI - No API keys needed)
+agent = ActiveAgent::Agent.new(role: "Local Assistant", goal: "Summarize", provider: :ollama, model: "llama3")
+```
+
+---
+
+## License
+
+MIT License.

data/bin/active_agent

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative '../lib/active_agent'
+
+ActiveAgent::CLI.start(ARGV)

data/bin/active_agent_ai

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative '../lib/active_agent'
+
+ActiveAgent::CLI.start(ARGV)

data/lib/active_agent/agent.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'providers/openai'
+require_relative 'providers/anthropic'
+require_relative 'providers/gemini'
+require_relative 'providers/ollama'
+
+module ActiveAgent
+  # Defines an autonomous AI Agent with persona, tools, and execution capabilities.
+  class Agent
+    attr_reader :role, :goal, :backstory, :tools, :provider
+
+    def initialize(role:, goal:, backstory: '', tools: [], provider: :openai, model: nil, api_key: nil, api_url: nil)
+      @role = role
+      @goal = goal
+      @backstory = backstory
+      @tools = tools.map { |t| t.is_a?(Class) ? t.new : t }
+      @provider = build_provider(provider, model: model, api_key: api_key, api_url: api_url)
+    end
+
+    def execute_task(task_description, expected_output: nil, context: nil)
+      system_prompt = build_system_prompt
+      user_prompt = build_user_prompt(task_description, expected_output: expected_output, context: context)
+
+      messages = [
+        { role: 'system', content: system_prompt },
+        { role: 'user', content: user_prompt }
+      ]
+
+      max_tool_loops = 5
+      loop_count = 0
+
+      while loop_count < max_tool_loops
+        response = @provider.chat(messages: messages, tools: @tools)
+        content = response[:content]
+        tool_calls = response[:tool_calls]
+
+        return content unless tool_calls && !tool_calls.empty?
+
+        messages << { role: 'assistant', content: content, tool_calls: tool_calls }
+
+        tool_calls.each do |tool_call|
+          func_name = tool_call.dig('function', 'name')
+          raw_args = tool_call.dig('function', 'arguments')
+          args = raw_args.is_a?(String) ? JSON.parse(raw_args, symbolize_names: true) : raw_args
+
+          matching_tool = @tools.find { |t| t.class.name.split('::').last.downcase == func_name.to_s.downcase }
+          tool_result = if matching_tool
+                          matching_tool.perform(**args)
+                        else
+                          "Tool #{func_name} not found."
+                        end
+
+          messages << { role: 'tool', tool_call_id: tool_call['id'], content: tool_result.to_s }
+        end
+        loop_count += 1
+      end
+
+      messages.last[:content] || 'Execution completed.'
+    end
+
+    private
+
+    def build_system_prompt
+      prompt = "You are #{@role}.\n"
+      prompt += "Your Goal: #{@goal}\n"
+      prompt += "Your Backstory: #{@backstory}\n" if @backstory && !@backstory.empty?
+      prompt += "\nRespond precisely and execute assigned tasks professionally."
+      prompt
+    end
+
+    def build_user_prompt(task_description, expected_output:, context:)
+      prompt = "Task: #{task_description}\n"
+      prompt += "Expected Output: #{expected_output}\n" if expected_output
+      prompt += "\nContext from Previous Steps:\n#{context}\n" if context && !context.to_s.strip.empty?
+      prompt
+    end
+
+    def build_provider(provider, model:, api_key:, api_url:)
+      return provider if provider.is_a?(Providers::Base)
+
+      case provider.to_s.downcase.to_sym
+      when :anthropic, :claude
+        Providers::Anthropic.new(model: model || 'claude-3-5-sonnet-20241022', api_key: api_key, api_url: api_url)
+      when :gemini
+        Providers::Gemini.new(model: model || 'gemini-1.5-flash', api_key: api_key, api_url: api_url)
+      when :ollama
+        Providers::Ollama.new(model: model || 'llama3', api_key: api_key, api_url: api_url)
+      else
+        Providers::OpenAI.new(model: model || 'gpt-4o-mini', api_key: api_key, api_url: api_url)
+      end
+    end
+  end
+end

data/lib/active_agent/cli.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module ActiveAgent
+  class CLI < Thor
+    desc 'kickoff FILE', 'Run a multi-agent team workflow defined in a Ruby file'
+    def kickoff(file_path)
+      unless File.exist?(file_path)
+        say_error "File not found: #{file_path}", :red
+        exit(1)
+      end
+
+      say "🚀 Launching ActiveAgent team from #{file_path}...", :green
+      load file_path
+    end
+
+    desc 'version', 'Show ActiveAgent version'
+    def version
+      say "ActiveAgent v#{ActiveAgent::VERSION}", :blue
+    end
+  end
+end

data/lib/active_agent/providers/anthropic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveAgent
+  module Providers
+    class Anthropic < Base
+      DEFAULT_URL = 'https://api.anthropic.com/v1/messages'
+
+      def initialize(model: 'claude-3-5-sonnet-20241022', api_key: ENV.fetch('ANTHROPIC_API_KEY', nil), api_url: nil)
+        url = api_url || DEFAULT_URL
+        super(model: model, api_key: api_key, api_url: url)
+
+        raise Error, 'ANTHROPIC_API_KEY is required for Anthropic provider' unless @api_key || ENV['MOCK_AGENT_RESPONSE']
+      end
+
+      def chat(messages:, tools: [])
+        headers = {
+          'Content-Type' => 'application/json',
+          'x-api-key' => @api_key,
+          'anthropic-version' => '2023-06-01'
+        }
+
+        system_message = messages.find { |m| m[:role] == 'system' }&.fetch(:content, '')
+        user_messages = messages.reject { |m| m[:role] == 'system' }
+
+        payload = {
+          model: @model,
+          max_tokens: 4096,
+          system: system_message,
+          messages: user_messages,
+          temperature: 0.2
+        }
+
+        data = http_post(@api_url, headers, payload)
+        content = data.dig('content', 0, 'text')
+
+        { content: content, tool_calls: nil }
+      end
+    end
+  end
+end

data/lib/active_agent/providers/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module ActiveAgent
+  module Providers
+    class Base
+      attr_reader :model, :api_key, :api_url
+
+      def initialize(model:, api_key: nil, api_url: nil)
+        @model = model
+        @api_key = api_key
+        @api_url = api_url
+      end
+
+      def chat(messages:, tools: [])
+        raise NotImplementedError, "#{self.class.name}#chat must be implemented"
+      end
+
+      private
+
+      def http_post(url, headers, body)
+        return mock_response if ENV['MOCK_AGENT_RESPONSE']
+
+        uri = URI(url)
+        request = Net::HTTP::Post.new(uri)
+        headers.each { |k, v| request[k] = v }
+        request.body = body.is_a?(String) ? body : body.to_json
+
+        use_ssl = uri.scheme == 'https'
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: use_ssl) do |http|
+          http.request(request)
+        end
+
+        raise ActiveAgent::Error, "API Error (#{uri.host}): #{response.code} - #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)
+      end
+
+      def mock_response
+        {
+          'choices' => [
+            {
+              'message' => {
+                'content' => ENV.fetch('MOCK_AGENT_RESPONSE', nil)
+              }
+            }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/active_agent/providers/gemini.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveAgent
+  module Providers
+    class Gemini < Base
+      DEFAULT_URL = 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions'
+
+      def initialize(model: 'gemini-1.5-flash', api_key: nil, api_url: nil)
+        key = api_key || ENV.fetch('GEMINI_API_KEY', nil) || ENV.fetch('GOOGLE_API_KEY', nil)
+        url = api_url || DEFAULT_URL
+        super(model: model, api_key: key, api_url: url)
+
+        raise Error, 'GEMINI_API_KEY or GOOGLE_API_KEY is required for Gemini provider' unless @api_key || ENV['MOCK_AGENT_RESPONSE']
+      end
+
+      def chat(messages:, tools: [])
+        headers = {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@api_key}"
+        }
+
+        payload = {
+          model: @model,
+          messages: messages,
+          temperature: 0.2
+        }
+
+        data = http_post(@api_url, headers, payload)
+        message = data.dig('choices', 0, 'message') || {}
+
+        { content: message['content'], tool_calls: nil }
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveAgent
+  module Providers
+    class Ollama < Base
+      DEFAULT_URL = 'http://localhost:11434/v1/chat/completions'
+
+      def initialize(model: 'llama3', api_key: nil, api_url: nil)
+        url = api_url || DEFAULT_URL
+        super(model: model, api_key: api_key, api_url: url)
+      end
+
+      def chat(messages:, tools: [])
+        headers = { 'Content-Type' => 'application/json' }
+        payload = {
+          model: @model,
+          messages: messages,
+          temperature: 0.2
+        }
+
+        data = http_post(@api_url, headers, payload)
+        message = data.dig('choices', 0, 'message') || {}
+
+        { content: message['content'], tool_calls: nil }
+      end
+    end
+  end
+end

data/lib/active_agent/providers/openai.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module ActiveAgent
+  module Providers
+    class OpenAI < Base
+      DEFAULT_URL = 'https://api.openai.com/v1/chat/completions'
+
+      def initialize(model: 'gpt-4o-mini', api_key: ENV.fetch('OPENAI_API_KEY', nil), api_url: nil)
+        url = api_url || DEFAULT_URL
+        super(model: model, api_key: api_key, api_url: url)
+
+        raise Error, 'OPENAI_API_KEY is required for OpenAI provider' unless @api_key || ENV['MOCK_AGENT_RESPONSE']
+      end
+
+      def chat(messages:, tools: [])
+        headers = {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@api_key}"
+        }
+
+        payload = {
+          model: @model,
+          messages: messages,
+          temperature: 0.2
+        }
+
+        payload[:tools] = tools.map { |t| { type: 'function', function: t.to_openai_function } } if tools && !tools.empty?
+
+        data = http_post(@api_url, headers, payload)
+        message = data.dig('choices', 0, 'message') || {}
+
+        {
+          content: message['content'],
+          tool_calls: message['tool_calls']
+        }
+      end
+    end
+  end
+end

data/lib/active_agent/task.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # Defines a discrete task to be executed by an assigned Agent.
+  class Task
+    attr_reader :description, :expected_output, :agent
+    attr_accessor :output
+
+    def initialize(description:, agent:, expected_output: nil)
+      @description = description
+      @agent = agent
+      @expected_output = expected_output
+      @output = nil
+    end
+
+    def execute(context: nil)
+      @output = @agent.execute_task(
+        @description,
+        expected_output: @expected_output,
+        context: context
+      )
+      @output
+    end
+  end
+end

data/lib/active_agent/team.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # Orchestrates multiple agents and tasks in sequential or hierarchical processes.
+  class Team
+    attr_reader :agents, :tasks, :process
+
+    def initialize(agents:, tasks:, process: :sequential)
+      @agents = agents
+      @tasks = tasks
+      @process = process
+    end
+
+    def kickoff
+      accumulated_context = []
+
+      @tasks.each_with_index do |task, index|
+        context_str = accumulated_context.last
+        say_verbose "🤖 Task #{index + 1}/#{@tasks.size} [#{task.agent.role}]: #{task.description[0..80]}..."
+
+        result = task.execute(context: context_str)
+        accumulated_context << result
+      end
+
+      accumulated_context.last
+    end
+
+    private
+
+    def say_verbose(msg)
+      puts msg if ENV['VERBOSE'] || $stdout.tty?
+    end
+  end
+end

data/lib/active_agent/tool.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # Abstract base class for tools that Agents can execute.
+  class Tool
+    class << self
+      def description(desc = nil)
+        if desc
+          @description = desc
+        else
+          @description || "Tool: #{name}"
+        end
+      end
+
+      def param(name, type: :string, desc: '', required: true)
+        params_schema[name] = { type: type, description: desc, required: required }
+      end
+
+      def params_schema
+        @params_schema ||= {}
+      end
+
+      def to_openai_function
+        properties = {}
+        required_fields = []
+
+        params_schema.each do |param_name, options|
+          properties[param_name] = {
+            type: options[:type].to_s,
+            description: options[:description]
+          }
+          required_fields << param_name.to_s if options[:required]
+        end
+
+        {
+          name: name.split('::').last.downcase,
+          description: description,
+          parameters: {
+            type: 'object',
+            properties: properties,
+            required: required_fields
+          }
+        }
+      end
+    end
+
+    def to_openai_function
+      self.class.to_openai_function
+    end
+
+    def perform(**_args)
+      raise NotImplementedError, "#{self.class.name}#perform must be implemented"
+    end
+  end
+end

data/lib/active_agent/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  VERSION = '0.1.0'
+end

data/lib/active_agent.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'active_agent/version'
+require_relative 'active_agent/tool'
+require_relative 'active_agent/providers/base'
+require_relative 'active_agent/providers/openai'
+require_relative 'active_agent/providers/anthropic'
+require_relative 'active_agent/providers/gemini'
+require_relative 'active_agent/providers/ollama'
+require_relative 'active_agent/agent'
+require_relative 'active_agent/task'
+require_relative 'active_agent/team'
+require_relative 'active_agent/cli'
+
+module ActiveAgent
+  class Error < StandardError; end
+end

data/lib/active_agent_ai.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'active_agent'

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: active_agent_ai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aditya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: Orchestrate autonomous AI agent teams with roles, tools, tasks, and multi-provider
+  LLMs in 100% native Ruby.
+email: 
+executables:
+- active_agent_ai
+- active_agent
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/active_agent
+- bin/active_agent_ai
+- lib/active_agent.rb
+- lib/active_agent/agent.rb
+- lib/active_agent/cli.rb
+- lib/active_agent/providers/anthropic.rb
+- lib/active_agent/providers/base.rb
+- lib/active_agent/providers/gemini.rb
+- lib/active_agent/providers/ollama.rb
+- lib/active_agent/providers/openai.rb
+- lib/active_agent/task.rb
+- lib/active_agent/team.rb
+- lib/active_agent/tool.rb
+- lib/active_agent/version.rb
+- lib/active_agent_ai.rb
+homepage: https://github.com/aditya-8108/active_agent
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aditya-8108/active_agent
+  source_code_uri: https://github.com/aditya-8108/active_agent
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Native Multi-Agent AI Framework for Ruby & Rails
+test_files: []