chorus-llm 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9aaa6c14d9fe4b979246f8fbf95ae878c1e05178ebdffd6c90ad1f9d73c1d17
+  data.tar.gz: c4d5473d68812262c3670d972ed42791d758990a204745855d87cc55c94c66c7
+SHA512:
+  metadata.gz: f3e1b1df26ef99d02da3bcf161088fe5650d4d959061ad229015b2a95b98687fc5864d34b13038905673353b7ac2fd2b14a4724865432f14fc9f7a3f0752c19b
+  data.tar.gz: 62f5a01e91cbc78bc6adcd05e7649ac06a1300067bb37a4d3ff95e16f23044683d314b9fce3a07c96de1982ad1cc5e65c5f58ea834c1be0a1c4711934c0b2c18

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amayyas
+
+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, INCLUDING 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,173 @@
+# Chorus
+
+[![CI](https://github.com/Amayyas/Chorus/actions/workflows/ci.yml/badge.svg)](https://github.com/Amayyas/Chorus/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/chorus-llm.svg)](https://rubygems.org/gems/chorus-llm)
+
+Chorus is a Ruby framework for orchestrating multiple specialized LLM agents.
+
+## The problem
+
+Most multi-agent frameworks replay the entire conversation history to every
+agent on every call. It works, but it wastes tokens (money and latency) and
+pollutes each agent's context with exchanges that aren't relevant to it.
+
+Chorus takes a different approach: a **router** dynamically decides which
+agent should handle a message, and a **shared context** hands that agent only
+a **relevant slice** of the history:
+
+- the current message (the task at hand),
+- its own past exchanges (role-based continuity of memory),
+- a short summary of what other agents have been doing (visibility without pollution).
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem "chorus-llm"
+```
+
+Then `bundle install`. The library loads via `require "chorus"`:
+
+```ruby
+require "chorus"
+```
+
+To work on this repo:
+
+```bash
+bundle install
+```
+
+Chorus needs an Anthropic API key to make real calls (the test suite never
+makes network calls):
+
+```bash
+export ANTHROPIC_API_KEY="sk-ant-..."
+```
+
+## Minimal usage example
+
+```ruby
+require "chorus"
+
+orchestrator = Chorus::Orchestrator.new
+
+result = orchestrator.handle("There's a bug in my sort function")
+# => { agent: :coder, response: "..." }
+
+result = orchestrator.handle("What is the capital of France?")
+# => { agent: :research, response: "..." }
+```
+
+Under the hood, on every call:
+
+1. `Chorus::Router#route` picks the agent (`:coder` or `:research`) based on
+   keywords in the message.
+2. `Chorus::Context#slice_for` builds the relevant context slice for that
+   agent.
+3. The agent (`Chorus::Agents::CoderAgent` or `Chorus::Agents::ResearchAgent`)
+   sends that slice to the Anthropic API via `Chorus::Client`.
+4. The response is recorded in `Chorus::Context`, tagged with the name of the
+   agent that produced it.
+
+## Running the tests
+
+```bash
+bundle exec rspec       # tests only
+bundle exec rubocop     # lint only
+bundle exec rake        # both (Rakefile default task)
+```
+
+No test makes a network call — `Chorus::Client` is always mocked.
+
+## Running the demo
+
+`examples/demo.rb` simulates a 5-message conversation alternating between
+coding and research tasks, and makes REAL API calls (unlike the test suite).
+Requires `ANTHROPIC_API_KEY`:
+
+```bash
+ANTHROPIC_API_KEY="sk-ant-..." ruby examples/demo.rb
+```
+
+For each message, the script prints the message received, the agent chosen
+by the router, the size of the context slice sent, and the response.
+
+## Architecture
+
+```
+lib/chorus/
+├── client.rb              # sole point of contact with the Anthropic API (net/http)
+├── agent.rb                # base class: factors out the call to Client
+├── agents/
+│   ├── coder_agent.rb      # :coder — code, debugging, explaining code
+│   └── research_agent.rb   # :research — research, synthesis, factual Q&A
+├── context.rb              # full history + slice_for (the core of the concept)
+├── router.rb               # route(message) -> :coder | :research
+└── orchestrator.rb         # entry point: handle(user_message)
+```
+
+## CI/CD
+
+### Continuous integration (`.github/workflows/ci.yml`)
+
+On every push and pull request:
+
+- **Tests** — `bundle exec rspec` across a Ruby 3.2 / 3.3 / 3.4 matrix.
+- **RuboCop** — lint (`.rubocop.yml`, with `rubocop-rspec` and `rubocop-performance`).
+- **bundler-audit** — scans dependencies against the RubyGems advisory database.
+- **Gem build** — `gem build chorus-llm.gemspec` must succeed (catches
+  gemspec errors before they break a release).
+
+### Automated releases (`.github/workflows/release.yml`)
+
+Versioning follows [Conventional Commits](https://www.conventionalcommits.org/)
+via [release-please](https://github.com/googleapis/release-please):
+
+1. Every commit on `main` prefixed with `feat:`, `fix:`, `feat!:`, etc. updates
+   (or creates) a Release PR that bumps `lib/chorus/version.rb` and generates
+   `CHANGELOG.md`.
+2. Merging that PR automatically:
+   - creates the Git tag (`vX.Y.Z`) and a GitHub Release,
+   - publishes to [RubyGems.org](https://rubygems.org/gems/chorus-llm) via
+     [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/)
+     (OIDC — no RubyGems API key stored as a GitHub secret).
+
+**One-time manual configuration** (not automatable from code):
+
+- On RubyGems.org, a trusted publisher links the `chorus-llm` gem to the
+  `Amayyas/Chorus` repo, the `release.yml` workflow, and the `release`
+  environment.
+- In the repo's GitHub settings, a `release` environment exists
+  (Settings → Environments) — used by the publish job.
+- In Settings → Actions → General, *"Allow GitHub Actions to create and
+  approve pull requests"* is enabled so release-please can open its Release
+  PRs.
+
+### Expected commit format
+
+release-please needs [Conventional Commits](https://www.conventionalcommits.org/) to know what to bump:
+
+| Prefix | Effect |
+|---|---|
+| `fix: ...` | patch (0.1.0 → 0.1.1) |
+| `feat: ...` | minor (0.1.0 → 0.2.0) |
+| `feat!: ...` or `BREAKING CHANGE:` in the body | major (0.1.0 → 1.0.0) |
+| `chore:`, `docs:`, `test:`, `refactor:` | no bump, but listed in the CHANGELOG depending on config |
+
+## Roadmap — what's NOT in the MVP (v0.1.0)
+
+This version proves the concept with a minimal but complete foundation. It
+intentionally does not include:
+
+- **LLM-based router** — routing is currently keyword matching, not a call to
+  a classification model.
+- **Persistent long-term memory** — all state lives in the Ruby process's
+  memory; nothing is saved to disk or a database.
+- **More than 2 agents** — only `CoderAgent` and `ResearchAgent` exist.
+- **Explicit agent handoff** — an agent cannot delegate to another mid-response;
+  each message is handled by a single agent from start to finish.
+- **LLM-generated summaries** — the other-agents summary in `slice_for` is a
+  simple concatenation of truncated subjects, not an API call.
+- **Advanced error handling** (retries, backoff, etc.) on API calls.

data/chorus-llm.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "lib/chorus/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "chorus-llm"
+  spec.version = Chorus::VERSION
+  spec.authors = ["Amayyas"]
+  spec.email = ["amayyasadn@gmail.com"]
+
+  spec.summary = "Ruby framework for multi-agent LLM orchestration with contextual routing."
+  spec.description = <<~DESC
+    Chorus routes each incoming task to the right specialized LLM agent and hands it
+    only the relevant slice of shared context, instead of replaying the full
+    conversation history to every agent.
+  DESC
+  spec.homepage = "https://github.com/Amayyas/Chorus"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir["lib/**/*.rb", "README.md", "LICENSE.txt", "chorus-llm.gemspec"]
+  spec.require_paths = ["lib"]
+end

data/lib/chorus/agent.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chorus
+  # Base class for every Chorus agent. A concrete agent only needs to define
+  # its `name` and `system_prompt` — the call to the LLM is factored out here.
+  class Agent
+    # @return [Symbol] the agent's identifier, e.g. :coder
+    attr_reader :name
+
+    # @return [String] the system prompt describing this agent's role and limits
+    attr_reader :system_prompt
+
+    # @param client [Chorus::Client] the API client used to talk to Claude
+    def initialize(client:)
+      @client = client
+    end
+
+    # Sends a context slice to the LLM and returns its text response.
+    #
+    # @param context_slice [Array<Hash>] messages formatted as `{role:, content:}`,
+    #   as produced by `Chorus::Context#slice_for`.
+    # @return [String] the agent's response text
+    def call(context_slice)
+      @client.chat(system_prompt: system_prompt, messages: context_slice)
+    end
+  end
+end

data/lib/chorus/agents/coder_agent.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../agent"
+
+module Chorus
+  module Agents
+    # Handles code-related tasks: writing, debugging, and explaining code.
+    class CoderAgent < Chorus::Agent
+      SYSTEM_PROMPT = <<~PROMPT
+        You are Chorus's coding agent. You write, debug, and explain code.
+        Be precise and give runnable examples when relevant. If a task is not
+        related to code, say so briefly instead of improvising an answer.
+      PROMPT
+
+      def initialize(client:)
+        super
+        @name = :coder
+        @system_prompt = SYSTEM_PROMPT
+      end
+    end
+  end
+end

data/lib/chorus/agents/research_agent.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../agent"
+
+module Chorus
+  module Agents
+    # Handles research/factual/explanatory tasks: information lookup and synthesis.
+    class ResearchAgent < Chorus::Agent
+      SYSTEM_PROMPT = <<~PROMPT
+        You are Chorus's research agent. You answer questions that require
+        factual explanation, synthesis of information, or general knowledge.
+        Be concise and cite the reasoning behind your answer when useful.
+      PROMPT
+
+      def initialize(client:)
+        super
+        @name = :research
+        @system_prompt = SYSTEM_PROMPT
+      end
+    end
+  end
+end

data/lib/chorus/client.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Chorus
+  # Raised when ANTHROPIC_API_KEY is not set in the environment.
+  class MissingAPIKeyError < StandardError
+    def initialize(msg = "ANTHROPIC_API_KEY is not set. Export it before using Chorus.")
+      super
+    end
+  end
+
+  # Raised when the Anthropic API returns a non-2xx response.
+  class APIError < StandardError; end
+
+  # Thin wrapper around the Anthropic Messages API. This is the ONLY class in
+  # Chorus allowed to perform HTTP calls — every agent goes through it.
+  class Client
+    API_URL = "https://api.anthropic.com/v1/messages"
+    ANTHROPIC_VERSION = "2023-06-01"
+    DEFAULT_MODEL = "claude-opus-4-8"
+    DEFAULT_MAX_TOKENS = 4096
+
+    # @param api_key [String, nil] Anthropic API key. Defaults to ENV["ANTHROPIC_API_KEY"].
+    # @param model [String] model id to use for every call made by this client.
+    def initialize(api_key: ENV.fetch("ANTHROPIC_API_KEY", nil), model: DEFAULT_MODEL)
+      raise MissingAPIKeyError if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @model = model
+    end
+
+    # Sends a single-turn (or multi-turn) request to the Messages API.
+    #
+    # @param system_prompt [String] the system prompt describing the agent's role.
+    # @param messages [Array<Hash>] conversation turns, each `{role:, content:}`.
+    # @param max_tokens [Integer] maximum tokens to generate.
+    # @return [String] the text of Claude's response.
+    def chat(system_prompt:, messages:, max_tokens: DEFAULT_MAX_TOKENS)
+      response = post_message(system_prompt: system_prompt, messages: messages, max_tokens: max_tokens)
+      extract_text(response)
+    end
+
+    private
+
+    def post_message(system_prompt:, messages:, max_tokens:)
+      uri = URI(API_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = build_request(uri, system_prompt: system_prompt, messages: messages, max_tokens: max_tokens)
+      response = http.request(request)
+
+      # The interpolated error message is clearer on one line than split
+      # across a modifier-if, even though it runs right up against the
+      # line-length limit.
+      # rubocop:disable Style/IfUnlessModifier
+      unless response.is_a?(Net::HTTPSuccess)
+        raise APIError, "Anthropic API error (#{response.code}): #{response.body}"
+      end
+      # rubocop:enable Style/IfUnlessModifier
+
+      JSON.parse(response.body)
+    end
+
+    def build_request(uri, system_prompt:, messages:, max_tokens:)
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request["x-api-key"] = @api_key
+      request["anthropic-version"] = ANTHROPIC_VERSION
+      request.body = JSON.generate(
+        model: @model,
+        max_tokens: max_tokens,
+        system: system_prompt,
+        messages: messages
+      )
+      request
+    end
+
+    def extract_text(response)
+      content = response.fetch("content", [])
+      text_block = content.find { |block| block["type"] == "text" }
+      text_block ? text_block["text"] : ""
+    end
+  end
+end

data/lib/chorus/context.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Chorus
+  # Represents the full shared state of a conversation, and knows how to carve
+  # out the slice of it that is relevant to a given agent and task.
+  #
+  # This class is the heart of Chorus's concept: instead of replaying the
+  # entire conversation to every agent, `slice_for` builds a small, targeted
+  # view of the context. See the comments inside `slice_for` for the exact
+  # rules — this logic is intentionally simple in v0.1.0 (no LLM calls) and
+  # is the primary thing to refine in v0.2.0.
+  class Context
+    Message = Struct.new(:role, :content, :agent, :timestamp, keyword_init: true)
+
+    # How many characters of a task we keep when summarizing another agent's
+    # activity for a teammate. Kept short on purpose — it's a pointer, not a
+    # transcript.
+    SUBJECT_LENGTH = 60
+
+    def initialize
+      @messages = []
+    end
+
+    # @param role [Symbol] :user or :assistant
+    # @param content [String] the message text
+    # @param agent [Symbol, nil] which agent produced this message (nil for user messages)
+    # @return [void]
+    def add_message(role:, content:, agent: nil)
+      @messages << Message.new(role: role, content: content, agent: agent, timestamp: Time.now)
+    end
+
+    # @return [Array<Message>] the complete, unfiltered history — for debugging/logging only.
+    def full_history
+      @messages.dup
+    end
+
+    # Builds the context slice for `agent_name` working on `task`.
+    #
+    # The slice always contains, in order:
+    #   1. A one-line summary of what OTHER agents have been doing, so this
+    #      agent has situational awareness without the full transcript of
+    #      their conversations. Built by concatenating short subjects
+    #      (truncated prior task text) — no LLM call involved in v0.1.0.
+    #   2. This agent's own past (task, response) pairs, so it remembers what
+    #      it has already said — continuity of memory per role.
+    #   3. The current task, which is always the final entry.
+    #
+    # The Anthropic API only requires the conversation to start with a `user`
+    # turn; consecutive same-role turns are merged server-side, so we don't
+    # need to strictly alternate roles here.
+    #
+    # @param agent_name [Symbol] the agent about to handle `task`, e.g. :coder
+    # @param task [String] the current user message
+    # @return [Array<Hash>] messages shaped as `{role:, content:}`, ready for `Chorus::Client#chat`
+    def slice_for(agent_name, task)
+      slice = []
+
+      summary = other_agents_summary(agent_name)
+      slice << { role: "user", content: "[Other agents' context] #{summary}" } if summary
+
+      slice.concat(own_history_for(agent_name))
+
+      slice << { role: "user", content: task }
+      slice
+    end
+
+    private
+
+    # Reconstructs (task, response) pairs previously produced by `agent_name`,
+    # so it can pick up where it left off instead of starting cold each time.
+    def own_history_for(agent_name)
+      pairs = []
+
+      @messages.each_with_index do |message, index|
+        next unless message.role == :assistant && message.agent == agent_name
+
+        preceding_task = preceding_user_message(index)
+        pairs << { role: "user", content: preceding_task } if preceding_task
+        pairs << { role: "assistant", content: message.content }
+      end
+
+      pairs
+    end
+
+    # Short, no-LLM summary of what agents OTHER than `agent_name` have been
+    # asked to do, so `agent_name` has visibility without full pollution.
+    def other_agents_summary(agent_name)
+      subjects = @messages.each_with_index.filter_map do |message, index|
+        next unless other_agent_response?(message, agent_name)
+
+        preceding_task = preceding_user_message(index)
+        next unless preceding_task
+
+        "#{message.agent}: #{truncate(preceding_task)}"
+      end
+
+      return nil if subjects.empty?
+
+      subjects.uniq.join("; ")
+    end
+
+    def other_agent_response?(message, agent_name)
+      message.role == :assistant && message.agent && message.agent != agent_name
+    end
+
+    # @return [String, nil] the content of the user message right before
+    #   `@messages[index]`, or nil if there isn't one (e.g. this is the first
+    #   message, or the previous entry wasn't a user turn).
+    def preceding_user_message(index)
+      return nil unless index.positive?
+
+      preceding = @messages[index - 1]
+      preceding.content if preceding.role == :user
+    end
+
+    def truncate(text)
+      return text if text.length <= SUBJECT_LENGTH
+
+      "#{text[0, SUBJECT_LENGTH]}…"
+    end
+  end
+end

data/lib/chorus/orchestrator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "context"
+require_relative "router"
+require_relative "agents/coder_agent"
+require_relative "agents/research_agent"
+
+module Chorus
+  # Main entry point of Chorus. Ties together the Router, Context and Agents:
+  # for every incoming user message it picks an agent, builds that agent's
+  # context slice, calls it, and records the response.
+  class Orchestrator
+    # @return [Chorus::Context] the shared conversation state
+    attr_reader :context
+
+    # @param client [Chorus::Client] API client shared by all agents
+    # @param router [Chorus::Router] decides which agent handles a message
+    # @param context [Chorus::Context] shared conversation state
+    # @param agents [Hash{Symbol => Chorus::Agent}] agent name => agent instance
+    def initialize(client: Chorus::Client.new, router: Chorus::Router.new, context: Chorus::Context.new, agents: nil)
+      @client = client
+      @router = router
+      @context = context
+      @agents = agents || default_agents
+    end
+
+    # @param user_message [String] the incoming message to handle
+    # @return [Hash] `{agent: Symbol, response: String}`
+    def handle(user_message)
+      agent_name = @router.route(user_message)
+      agent = @agents.fetch(agent_name) { raise ArgumentError, "Unknown agent: #{agent_name}" }
+
+      @context.add_message(role: :user, content: user_message)
+
+      context_slice = @context.slice_for(agent_name, user_message)
+      response = agent.call(context_slice)
+
+      @context.add_message(role: :assistant, content: response, agent: agent_name)
+
+      { agent: agent_name, response: response }
+    end
+
+    private
+
+    def default_agents
+      {
+        coder: Chorus::Agents::CoderAgent.new(client: @client),
+        research: Chorus::Agents::ResearchAgent.new(client: @client)
+      }
+    end
+  end
+end

data/lib/chorus/router.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chorus
+  # Decides which agent should handle a given user message.
+  #
+  # v0.1.0 uses simple keyword matching (no LLM call). The public interface
+  # is a single method, `route`, so this class can be swapped for an
+  # LLM-based router later without touching `Orchestrator`.
+  class Router
+    # Words that, when present in a message, indicate a coding task.
+    CODER_KEYWORDS = %w[code bug function error debug script class method variable
+                        exception refactor].freeze
+
+    DEFAULT_AGENT = :research
+
+    # @param message [String] the raw user message
+    # @return [Symbol] the agent name that should handle this message (:coder or :research)
+    def route(message)
+      coding_task?(message) ? :coder : DEFAULT_AGENT
+    end
+
+    private
+
+    def coding_task?(message)
+      normalized = message.downcase
+      # rubocop:disable Style/ArrayIntersect -- `normalized` is a String, not
+      # an Array; Array#intersect? would raise a TypeError here. This is a
+      # substring check on each keyword, not an array-element intersection.
+      CODER_KEYWORDS.any? { |keyword| normalized.include?(keyword) }
+      # rubocop:enable Style/ArrayIntersect
+    end
+  end
+end

data/lib/chorus/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Chorus
+  VERSION = "0.2.0"
+end

data/lib/chorus.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "chorus/version"
+require_relative "chorus/client"
+require_relative "chorus/agent"
+require_relative "chorus/agents/coder_agent"
+require_relative "chorus/agents/research_agent"
+require_relative "chorus/context"
+require_relative "chorus/router"
+require_relative "chorus/orchestrator"
+
+# Chorus is a Ruby framework for orchestrating multiple specialized LLM
+# agents. A Router decides which agent should handle an incoming message, and
+# a Context builds a targeted slice of shared conversation state for that
+# agent — instead of replaying the full history to every call.
+module Chorus
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: chorus-llm
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Amayyas
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Chorus routes each incoming task to the right specialized LLM agent and hands it
+  only the relevant slice of shared context, instead of replaying the full
+  conversation history to every agent.
+email:
+- amayyasadn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- chorus-llm.gemspec
+- lib/chorus.rb
+- lib/chorus/agent.rb
+- lib/chorus/agents/coder_agent.rb
+- lib/chorus/agents/research_agent.rb
+- lib/chorus/client.rb
+- lib/chorus/context.rb
+- lib/chorus/orchestrator.rb
+- lib/chorus/router.rb
+- lib/chorus/version.rb
+homepage: https://github.com/Amayyas/Chorus
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Amayyas/Chorus
+  source_code_uri: https://github.com/Amayyas/Chorus
+  changelog_uri: https://github.com/Amayyas/Chorus/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby framework for multi-agent LLM orchestration with contextual routing.
+test_files: []