rcrewai 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb90e26000ddf4a2907b06150fdc87b1707fc701c6c61ba35db33339ed6f38d4
-  data.tar.gz: ba3435eb1918be328ce65faf2c3000553833b09778eb3b06f2a6191cae31aab4
+  metadata.gz: '0024080cd05b151b653bcedb4b29afea563e149f9d68dce1662d636a919020a9'
+  data.tar.gz: 53bb6b1376f88d1379cb0f877eeaa35aed0822f08df5f76d482e28d55101efe6
 SHA512:
-  metadata.gz: 992ac3d7368cb7690f11294b78fe876fcea29d48cffd001a355471a351c22c321563fbd390a0688951be6bcbd0f177322509e59cdd19cf8073e228784d96b503
-  data.tar.gz: 92e7db7609d4503693396f85735fd48633cb5204a34d2431e57ffcb7c758e693bff5b1282ed716899f4242bd9a26b0483f278c991dedb13b21d05894a59b7105
+  metadata.gz: b7923adbf161caa5361568268306513c92e5ffbddc3736cd91cd0fbccedd8cdd4230854f8310cf358964c7ccea09b1e43040e944f4c5472b0f5e58983bf37aaf
+  data.tar.gz: e4c9426c4e948fca50c3708a8a0e57588b4b18c51a5ac8df0bd2dd902aa2440a20d8d1f6a464333bb9c3244d5ff6901070645bb932fd5fb6e77f3d3f82ff9f83

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-07-07
+
+Turns the `:consensual` crew process from a stub into a real multi-agent
+consensus (propose → vote → pick). This is a behavior change to an existing
+process type — see `docs/upgrading-to-0.7.md`.
+
+### Changed
+- The `:consensual` crew process now performs real multi-agent consensus instead of silently running sequentially. For each task, up to `consensus_agents` agents (default 3) propose candidate answers, all participants score each candidate 0–10, and the highest-scored candidate wins (ties break toward the task's assigned agent). Configure via `Crew.new(process: :consensual, consensus_agents: N)`. A proposer that errors is dropped; if all proposals fail the task is marked failed. **Behavior change:** code relying on `:consensual`'s previous (accidental) sequential behavior should switch to `process: :sequential`. See `docs/upgrading-to-0.7.md`.
+
+## [0.6.1] - 2026-07-06
+
+Follow-ups to the 0.6.0 Cognitive Memory release, deepening the areas that
+shipped as focused first cuts. All additive and backward compatible.
+
+### Added
+- Multi-provider embeddings: `Knowledge::Embedder.new(provider:)` now supports `:openai` (default), `:azure`, `:google`, and `:ollama` embedding endpoints, removing the hard OpenAI dependency for RAG and memory. `:anthropic` raises a clear error (no first-party embeddings API). Per-provider default models via `DEFAULT_MODELS`; existing OpenAI usage is unchanged.
+- LLM-backed entity extraction: `EntityMemory` accepts a pluggable `extractor:` (anything responding to `call(text) -> [names]`); `RCrewAI::Memory::LlmEntityExtractor` prompts an LLM for entities (handling multi-word names the capitalized-token heuristic misses). Falls back to the heuristic when the extractor is absent, returns nothing, or raises. Wire via `Agent.new(memory: { entity_extractor: ... })`.
+- Bounded SQLite recall: `Memory::SqliteStore.new(max_candidates:)` (default 1000) caps how many most-recent rows a search cosines, keeping recall cost constant as total memory grows instead of brute-forcing every row. `nil` considers all rows.
+
 ## [0.6.0] - 2026-07-06
 
 Replaces the placeholder agent memory with a **cognitive memory** system —
@@ -198,7 +217,9 @@ output, guardrails, planning, and training/testing. See `ROADMAP.md`.
 - CLI usage documentation
 - Real-world use cases and examples
 
-[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/gkosmo/rcrewAI/compare/v0.6.1...v0.7.0
+[0.6.1]: https://github.com/gkosmo/rcrewAI/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/gkosmo/rcrewAI/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/gkosmo/rcrewAI/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/gkosmo/rcrewAI/compare/v0.3.0...v0.4.0

data/README.md

@@ -370,9 +370,10 @@ support = RCrewAI::Agent.new(name: 'support', role: '...', goal: '...',
 crew = RCrewAI::Crew.new('support_crew', knowledge: kb)
 ```
 
-Embeddings default to OpenAI's `text-embedding-3-small`; pass a custom
-`embedder:` (anything responding to `embed(texts)`) or vector store to swap the
-backend.
+Embeddings default to OpenAI's `text-embedding-3-small`. Use another provider
+with `RCrewAI::Knowledge::Embedder.new(provider: :ollama)` (also `:azure`,
+`:google`; `:anthropic` has no embeddings API), or pass any custom `embedder:`
+(anything responding to `embed(texts)`) / vector store to swap the backend.
 
 ## 🧠 Cognitive Memory
 
@@ -444,6 +445,26 @@ flow.state.id          # => automatic UUID
   or your own `#save`/`#load`) and call `flow.restore(id)` to resume.
 - Invoke a `Crew` inside any step, or pause with `human_feedback('Approve?')`.
 
+## 🗳️ Consensual Process
+
+For decisions where multiple perspectives matter, the `:consensual` process has
+several agents propose competing answers and vote to pick the best:
+
+```ruby
+crew = RCrewAI::Crew.new('panel', process: :consensual, consensus_agents: 3)
+crew.add_agent(junior)
+crew.add_agent(senior)
+crew.add_task(task)
+
+crew.execute   # each task: agents propose → all score 0–10 → highest wins
+```
+
+For every task, up to `consensus_agents` agents (default 3) propose a candidate
+answer, all participants score each candidate, and the highest-scored candidate
+becomes the result (ties break toward the task's assigned agent). A proposer that
+errors is dropped; if all proposals fail the task is marked failed. Consensus
+multiplies LLM calls, so `consensus_agents` bounds the cost on larger crews.
+
 ## 💡 Examples
 
 ### Hierarchical Team with Human Oversight

data/docs/superpowers/specs/2026-07-07-consensual-process-design.md

@@ -0,0 +1,82 @@
+# Consensual Process: propose → vote → pick
+
+**Date:** 2026-07-07
+**Status:** Approved design (pending implementation)
+**Target version:** `rcrewai` 0.7.0 (current is 0.6.1)
+**Scope:** Replace the stubbed `Process::Consensual` (which silently runs tasks sequentially) with a real multi-agent consensus: agents propose candidate answers, score each other's candidates, and the highest-scored candidate wins.
+
+---
+
+## Motivation
+
+`Crew.new('c', process: :consensual)` is a public, validated, documented process type. But `Process::Consensual#execute` currently just runs each task once (`execute_with_consensus` calls `task.execute` with a "for now, just execute normally" comment). A user selecting `:consensual` silently gets sequential behavior — the feature is advertised but not implemented. This is a latent honesty gap: fix the code to do what its name and comments promise ("agent voting/discussion").
+
+## Behavior
+
+For each task in the crew, instead of a single execution:
+
+1. **Propose** — up to `consensus_agents` agents (default 3, capped from the crew) each independently produce a candidate answer for the task.
+2. **Vote** — each participating agent scores every candidate 0–10 for how well it satisfies the task's description and expected output.
+3. **Pick** — the candidate with the highest total score wins. Ties break toward the task's assigned agent's candidate (or the first proposer if the assigned agent didn't propose).
+
+## Components
+
+All within `Process::Consensual`, replacing the stub. Result shape is unchanged
+(`{ task:, result:, status: }`) so `Crew#format_execution_results` needs no changes.
+
+- `execute` — iterate tasks, call `execute_with_consensus(task)`, log, return results.
+- `select_participants(task)` — first N agents (`consensus_agents`), always including the task's assigned agent if present and not already in the first N.
+- `gather_proposals(task, participants)` — each agent runs the task; returns `[{ agent:, content: }]`. A proposer that raises is dropped (logged), not fatal.
+- `score_candidates(task, candidates, participants)` — each participant scores each candidate via an LLM call; returns per-candidate total. Non-numeric / failed scores count as 0.
+- `pick_winner(task, scored)` — highest total; deterministic tie-break toward the task's assigned agent, else first proposer.
+
+## Configuration
+
+```ruby
+Crew.new('c', process: :consensual, consensus_agents: 3)
+```
+
+`consensus_agents` (default 3) caps how many agents propose and vote, bounding
+cost regardless of crew size. Read by the process from the crew.
+
+## Cost
+
+Bounded per task: N proposals + N×N scoring calls, N defaulting to 3
+(≈ 3 + 9 = 12 LLM calls/task worst case), independent of crew size.
+
+## Edge cases
+
+- **1 participant** → a single proposal, no meaningful vote; returns a valid result.
+- **A proposer errors** → that candidate is dropped; consensus continues with the rest.
+- **All proposals fail** → task marked `:failed` with the error, matching Sequential's rescue behavior.
+- **No agents in crew** → task `:failed` (nothing can propose).
+
+## Scoring mechanism
+
+Each participant is prompted: given the task (description + expected output) and a
+candidate answer, return a single integer 0–10. The response is parsed with a
+tolerant integer extraction (first integer in the text; clamp to 0–10; default 0
+on failure). Scores are summed across participants per candidate.
+
+## Backward compatibility
+
+`:consensual` already exists and validates. This changes only runtime behavior
+(from "silently sequential" to "actual consensus"). The async consensual path
+(`Crew#execute_consensual_async`, parallel aggregation) is intentionally left
+unchanged for this pass and noted in docs; expanding it is a possible follow-up.
+
+## Testing (TDD)
+
+Fake agents returning canned proposals and scores (no live LLM) prove:
+- highest-scored candidate wins
+- deterministic tie-break toward the task's assigned agent
+- `consensus_agents` cap respected on a larger crew
+- single-agent degradation returns a valid result
+- a proposer raising is dropped, consensus still completes
+- all-proposals-fail marks the task `:failed`
+
+## Rollout
+
+Ship in `0.7.0` (behavior change to an existing feature warrants a minor bump).
+`docs/upgrading-to-0.7.md` notes the behavior change; README documents the
+consensus flow and `consensus_agents`.

data/docs/upgrading-to-0.7.md

@@ -0,0 +1,36 @@
+# Upgrading to RCrewAI 0.7
+
+RCrewAI 0.7 makes the `:consensual` crew process do what its name promises.
+
+## Behavior change: `:consensual` process
+
+Previously, `Crew.new('c', process: :consensual)` was a stub — it silently ran
+tasks **sequentially**. As of 0.7 it performs real multi-agent consensus:
+
+1. **Propose** — up to `consensus_agents` agents (default 3) each produce a
+   candidate answer for the task.
+2. **Vote** — every participant scores each candidate 0–10.
+3. **Pick** — the highest-scored candidate wins (ties break toward the task's
+   assigned agent).
+
+### What you must do
+
+Nothing to keep your code running — the API is unchanged. But be aware:
+
+- If you were using `process: :consensual` and relying on its (accidental)
+  sequential behavior, switch to `process: :sequential` explicitly.
+- Consensus multiplies LLM calls (≈ N proposals + N×N scoring per task, N=3 by
+  default). Tune or bound it with `consensus_agents:`.
+
+```ruby
+crew = RCrewAI::Crew.new('panel', process: :consensual, consensus_agents: 3)
+```
+
+### Edge cases
+
+- One agent → a single proposal (no real vote), still a valid result.
+- A proposer that errors is dropped; consensus continues with the rest.
+- If every proposal fails, the task is marked failed.
+
+The async consensual path (`crew.execute(async: true)` with `:consensual`) is
+unchanged in this release (parallel aggregation).

data/examples/consensual_process_example.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Consensual process — agents propose competing answers and vote to pick one.
+#
+# For each task: up to `consensus_agents` agents each produce a candidate
+# answer, every participant scores each candidate 0-10, and the highest-scored
+# candidate wins (ties break toward the task's assigned agent).
+#
+# This example stubs the agents so it runs WITHOUT an API key. In real use each
+# agent calls your configured LLM to propose and to score.
+#
+# Run:
+#   ruby examples/consensual_process_example.rb
+
+require_relative '../lib/rcrewai'
+
+RCrewAI.configure(validate: false) do |c|
+  c.llm_provider = :openai
+  c.api_key = 'demo-key'
+end
+
+# A stand-in agent: proposes a fixed answer, and scores candidates by a simple
+# rubric (here: answers mentioning "trade-offs" are judged higher). A real
+# Agent proposes via execute_task and scores via its llm_client.
+class PanelAgent
+  attr_reader :name
+
+  def initialize(name, answer)
+    @name = name
+    @answer = answer
+  end
+
+  def execute_task(_task)
+    { content: @answer }
+  end
+
+  def llm_client
+    self
+  end
+
+  def chat(messages:, **)
+    candidate = messages.first[:content]
+    score = candidate.include?('trade-offs') ? 9 : 5
+    { content: score.to_s }
+  end
+end
+
+junior = PanelAgent.new('junior', 'Use PostgreSQL.')
+senior = PanelAgent.new('senior', 'Use PostgreSQL, but weigh the trade-offs vs. DynamoDB for scale.')
+
+crew = RCrewAI::Crew.new('architecture_panel', process: :consensual, consensus_agents: 3)
+crew.add_agent(junior)
+crew.add_agent(senior)
+
+task = RCrewAI::Task.new(name: 'db_choice', description: 'Recommend a database', agent: junior)
+crew.add_task(task)
+
+result = crew.execute
+
+puts "process: #{result[:process]}"
+puts "consensus winner: #{result[:results].first[:result].inspect}"
+puts '(the answer weighing trade-offs scored higher and won)'

data/lib/rcrewai/agent.rb

@@ -228,7 +228,8 @@ module RCrewAI
       return memory if memory.is_a?(Memory)
 
       opts = memory.is_a?(Hash) ? memory : {}
-      Memory.new(scope: opts.fetch(:scope, name), **opts.slice(:embedder, :store, :short_term_limit))
+      Memory.new(scope: opts.fetch(:scope, name),
+                 **opts.slice(:embedder, :store, :short_term_limit, :entity_extractor))
     end
 
     # Accepts a pre-built Knowledge::Base via +knowledge:+ or an array of

data/lib/rcrewai/crew.rb

@@ -22,6 +22,7 @@ module RCrewAI
       @planning = options.fetch(:planning, false)
       @planning_llm = options[:planning_llm]
       @planned = false
+      @consensus_agents = options.fetch(:consensus_agents, 3)
       @knowledge = build_knowledge(options[:knowledge], options[:knowledge_sources])
       @before_kickoff_hooks = []
       @after_kickoff_hooks = []
@@ -30,7 +31,7 @@ module RCrewAI
       validate_process_type!
     end
 
-    attr_reader :knowledge, :stream_sink, :last_inputs
+    attr_reader :knowledge, :stream_sink, :last_inputs, :consensus_agents
 
     def planning?
       @planning

data/lib/rcrewai/knowledge/embedder.rb

@@ -5,36 +5,100 @@ require 'faraday'
 
 module RCrewAI
   module Knowledge
-    # Turns text into embedding vectors. Defaults to OpenAI's embeddings API;
-    # #embed takes an array of strings and returns an array of vectors. Any
-    # object responding to #embed can be substituted (see specs).
+    # Turns text into embedding vectors. Supports multiple providers
+    # (OpenAI [default], Azure OpenAI, Google Gemini, Ollama); Anthropic has no
+    # first-party embeddings API and raises a clear error. `#embed` takes an
+    # array of strings and returns an array of vectors. Any object responding to
+    # `#embed` can be substituted.
     class Embedder
-      DEFAULT_MODEL = 'text-embedding-3-small'
+      DEFAULT_MODELS = {
+        openai: 'text-embedding-3-small',
+        azure: 'text-embedding-3-small',
+        google: 'text-embedding-004',
+        ollama: 'nomic-embed-text'
+      }.freeze
+
       OPENAI_URL = 'https://api.openai.com/v1/embeddings'
+      GOOGLE_BASE = 'https://generativelanguage.googleapis.com/v1beta'
+      OLLAMA_DEFAULT_URL = 'http://localhost:11434'
+
+      attr_reader :provider, :model
+
+      def initialize(provider: :openai, model: nil, api_key: nil, config: RCrewAI.configuration)
+        @provider = provider.to_sym
+        if @provider == :anthropic
+          raise EmbeddingError,
+                'anthropic does not provide an embeddings API; use :openai, :azure, :google, or :ollama'
+        end
 
-      def initialize(model: DEFAULT_MODEL, api_key: nil, config: RCrewAI.configuration)
-        @model = model
-        @api_key = api_key || config.openai_api_key || config.api_key
+        @config = config
+        @model = model || DEFAULT_MODELS[@provider] || DEFAULT_MODELS[:openai]
+        @api_key = api_key
       end
 
       def embed(texts)
         texts = Array(texts)
         return [] if texts.empty?
 
-        response = connection.post(OPENAI_URL) do |req|
-          req.headers['Authorization'] = "Bearer #{@api_key}"
-          req.headers['Content-Type'] = 'application/json'
-          req.body = JSON.generate(model: @model, input: texts)
+        send("embed_#{@provider}", texts)
+      end
+
+      private
+
+      def embed_openai(texts)
+        body = post_json(OPENAI_URL, { model: @model, input: texts },
+                         'Authorization' => "Bearer #{api_key_for(:openai)}")
+        body['data'].map { |d| d['embedding'] }
+      end
+
+      def embed_azure(texts)
+        base = @config.base_url
+        version = @config.api_version || '2024-02-01'
+        deployment = @config.deployment_name || @model
+        url = "#{base}/openai/deployments/#{deployment}/embeddings?api-version=#{version}"
+        body = post_json(url, { input: texts }, 'api-key' => api_key_for(:azure))
+        body['data'].map { |d| d['embedding'] }
+      end
+
+      def embed_google(texts)
+        key = api_key_for(:google)
+        texts.map do |text|
+          url = "#{GOOGLE_BASE}/models/#{@model}:embedContent?key=#{key}"
+          payload = { model: "models/#{@model}", content: { parts: [{ text: text }] } }
+          body = post_json(url, payload)
+          body.dig('embedding', 'values')
         end
+      end
 
+      def embed_ollama(texts)
+        base = @config.base_url || OLLAMA_DEFAULT_URL
+        texts.map do |text|
+          body = post_json("#{base}/api/embeddings", { model: @model, prompt: text })
+          body['embedding']
+        end
+      end
+
+      def post_json(url, payload, headers = {})
+        response = connection.post(url) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          headers.each { |k, v| req.headers[k] = v }
+          req.body = JSON.generate(payload)
+        end
         raise EmbeddingError, "embedding request failed: #{response.status}" unless response.success?
 
         body = response.body
-        body = JSON.parse(body) if body.is_a?(String)
-        body['data'].map { |d| d['embedding'] }
+        body.is_a?(String) ? JSON.parse(body) : body
       end
 
-      private
+      def api_key_for(provider)
+        return @api_key if @api_key
+
+        case provider
+        when :openai then @config.openai_api_key || @config.api_key
+        when :azure  then @config.azure_api_key || @config.api_key
+        when :google then @config.google_api_key || @config.api_key
+        end
+      end
 
       def connection
         @connection ||= Faraday.new do |f|

data/lib/rcrewai/memory/entity_memory.rb

@@ -11,8 +11,9 @@ module RCrewAI
       # Skip sentence-initial common words that happen to be capitalized.
       COMMON = %w[The A An I In On At To For Of With By And Or But It This That Who Where When].freeze
 
-      def initialize(scope:, embedder: nil, store: nil, limit: nil)
-        super
+      def initialize(scope:, embedder: nil, store: nil, limit: nil, extractor: nil)
+        super(scope: scope, embedder: embedder, store: store, limit: limit)
+        @extractor = extractor
         @entities = []
       end
 
@@ -39,7 +40,21 @@ module RCrewAI
 
       private
 
+      # Uses the custom extractor when provided, falling back to the heuristic
+      # if it's absent, returns nothing, or raises.
       def extract_entities(text)
+        if @extractor
+          begin
+            result = Array(@extractor.call(text))
+            return result unless result.empty?
+          rescue StandardError
+            # fall through to heuristic
+          end
+        end
+        heuristic_entities(text)
+      end
+
+      def heuristic_entities(text)
         text.to_s.scan(/\b([A-Z][a-zA-Z0-9]{1,})\b/).flatten.reject { |w| COMMON.include?(w) }.uniq
       end
     end

data/lib/rcrewai/memory/llm_entity_extractor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../output_schema'
+
+module RCrewAI
+  class Memory
+    # Extracts named entities from text with an LLM. Pass an instance as the
+    # `extractor:` for EntityMemory. Responds to `call(text) -> [names]`.
+    # Returns [] on any parse/LLM failure so EntityMemory falls back to the
+    # heuristic extractor — extraction is best-effort and never fatal.
+    class LlmEntityExtractor
+      PROMPT = <<~PROMPT
+        Extract the named entities (people, organizations, systems, products,
+        places, and key concepts) from the text below. Respond ONLY with a JSON
+        array of strings, e.g. ["Alice", "Payments", "Redis"]. No prose.
+
+        Text:
+      PROMPT
+
+      def initialize(llm)
+        @llm = llm
+      end
+
+      def call(text)
+        response = @llm.chat(messages: [{ role: 'user', content: "#{PROMPT}#{text}" }])
+        content = response.is_a?(Hash) ? response[:content] : response
+        parsed = OutputSchema.parse(content.to_s)
+        parsed.is_a?(Array) ? parsed.map(&:to_s) : []
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/sqlite_store.rb

@@ -15,11 +15,14 @@ module RCrewAI
     class SqliteStore
       DEFAULT_PATH = File.join(Dir.home, '.rcrewai', 'memory.db')
 
-      def initialize(path: DEFAULT_PATH)
+      # max_candidates bounds how many (most-recent) rows a search cosines, so
+      # recall cost stays constant as total memory grows. nil = consider all.
+      def initialize(path: DEFAULT_PATH, max_candidates: 1000)
         require 'sqlite3'
         ensure_parent_dir(path) unless path == ':memory:'
         @db = SQLite3::Database.new(path)
         @db.results_as_hash = true
+        @max_candidates = max_candidates
         create_schema
       end
 
@@ -37,7 +40,7 @@ module RCrewAI
       end
 
       def search(vector, k:, scope:)
-        all(scope: scope)
+        candidates(scope)
           .reject { |r| r[:vector].nil? }
           .map { |r| [r, Similarity.cosine(vector, r[:vector])] }
           .sort_by { |(_r, score)| -score }
@@ -55,6 +58,18 @@ module RCrewAI
 
       private
 
+      # The rows a search will consider: the most-recent @max_candidates within
+      # the scope (rowid tracks insertion order). Bounds cosine cost at scale.
+      def candidates(scope)
+        sql = 'SELECT * FROM memories WHERE scope = ? ORDER BY rowid DESC'
+        params = [scope]
+        if @max_candidates
+          sql += ' LIMIT ?'
+          params << @max_candidates
+        end
+        @db.execute(sql, params).map { |row| to_record(row) }
+      end
+
       def create_schema
         @db.execute(<<~SQL)
           CREATE TABLE IF NOT EXISTS memories (

data/lib/rcrewai/memory.rb

@@ -12,10 +12,10 @@ module RCrewAI
   # available, falls back to lexical similarity — so existing code behaves as
   # before, just with better recall once an embedder is configured.
   class Memory
-    def initialize(scope: 'default', embedder: nil, store: nil, short_term_limit: 100)
+    def initialize(scope: 'default', embedder: nil, store: nil, short_term_limit: 100, entity_extractor: nil)
       @short_term = ShortTermMemory.new(scope: scope, embedder: embedder, store: store, limit: short_term_limit)
       @long_term  = LongTermMemory.new(scope: scope, embedder: embedder, store: store)
-      @entity     = EntityMemory.new(scope: scope, embedder: embedder, store: store)
+      @entity     = EntityMemory.new(scope: scope, embedder: embedder, store: store, extractor: entity_extractor)
       @tool       = ToolMemory.new(scope: scope, embedder: embedder, store: store)
     end
 

data/lib/rcrewai/process.rb

@@ -373,23 +373,16 @@ module RCrewAI
       end
     end
 
+    # Multi-agent consensus: for each task, several agents propose candidate
+    # answers, all participants score each candidate, and the highest-scored
+    # candidate wins (ties break toward the task's assigned agent).
     class Consensual < Base
+      DEFAULT_CONSENSUS_AGENTS = 3
+
       def execute
         log_execution_start
-        @logger.info 'Consensual execution - agents collaborate on decisions'
-
-        # For now, implement as enhanced sequential with collaboration
-        # Full consensual process would involve agent voting/discussion
-        results = []
-
-        crew.tasks.each do |task|
-          @logger.info "Collaborative execution of task: #{task.name}"
-
-          # Simple consensus: let multiple agents provide input
-          consensus_result = execute_with_consensus(task)
-          results << consensus_result
-        end
-
+        @logger.info 'Consensual execution - agents propose, vote, and pick'
+        results = crew.tasks.map { |task| execute_with_consensus(task) }
         log_execution_end(results)
         results
       end
@@ -397,14 +390,89 @@ module RCrewAI
       private
 
       def execute_with_consensus(task)
-        # For now, just execute normally
-        # Future: implement actual consensus mechanisms
+        @logger.info "Consensus for task: #{task.name}"
+        participants = select_participants(task)
+        candidates = gather_proposals(task, participants)
 
-        result = task.execute
-        { task: task, result: result, status: :completed }
+        if candidates.empty?
+          return { task: task, result: 'All agents failed to produce a proposal', status: :failed }
+        end
+
+        scored = score_candidates(task, candidates, participants)
+        winner = pick_winner(task, scored)
+        task.result = winner[:content] if task.respond_to?(:result=)
+
+        { task: task, result: winner[:content], status: :completed }
       rescue StandardError => e
+        @logger.error "Consensus failed for #{task.name}: #{e.message}"
         { task: task, result: e.message, status: :failed }
       end
+
+      # First N agents, always including the task's assigned agent if present.
+      def select_participants(task)
+        cap = consensus_agent_cap
+        chosen = crew.agents.first(cap)
+        assigned = task.respond_to?(:agent) ? task.agent : nil
+        if assigned && crew.agents.include?(assigned) && !chosen.include?(assigned)
+          chosen = ([assigned] + chosen).first(cap)
+        end
+        chosen
+      end
+
+      def gather_proposals(task, participants)
+        participants.filter_map do |agent|
+          content = extract_content(agent.execute_task(task))
+          { agent: agent, content: content }
+        rescue StandardError => e
+          @logger.warn "Agent #{agent.name} failed to propose: #{e.message}"
+          nil
+        end
+      end
+
+      def score_candidates(task, candidates, participants)
+        candidates.map do |candidate|
+          total = participants.sum { |voter| score(voter, task, candidate[:content]) }
+          candidate.merge(score: total)
+        end
+      end
+
+      def score(voter, task, candidate_content)
+        prompt = <<~PROMPT
+          Score how well the following answer satisfies the task, from 0 to 10.
+          Reply with just the integer.
+
+          Task: #{task.description}
+          Expected output: #{task.respond_to?(:expected_output) ? task.expected_output : 'n/a'}
+
+          Answer:
+          #{candidate_content}
+        PROMPT
+        response = voter.llm_client.chat(messages: [{ role: 'user', content: prompt }])
+        parse_score(response.is_a?(Hash) ? response[:content] : response)
+      rescue StandardError
+        0
+      end
+
+      def pick_winner(task, scored)
+        assigned = task.respond_to?(:agent) ? task.agent : nil
+        scored.max_by { |c| [c[:score], c[:agent] == assigned ? 1 : 0] }
+      end
+
+      def parse_score(text)
+        match = text.to_s[/-?\d+/]
+        return 0 unless match
+
+        match.to_i.clamp(0, 10)
+      end
+
+      def extract_content(agent_result)
+        agent_result.is_a?(Hash) ? agent_result[:content].to_s : agent_result.to_s
+      end
+
+      def consensus_agent_cap
+        cap = crew.respond_to?(:consensus_agents) ? crew.consensus_agents : nil
+        [(cap || DEFAULT_CONSENSUS_AGENTS).to_i, 1].max
+      end
     end
 
     class ProcessError < RCrewAI::Error; end

data/lib/rcrewai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RCrewAI
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/rcrewai.rb

@@ -30,6 +30,7 @@ require_relative 'rcrewai/memory/base_memory'
 require_relative 'rcrewai/memory/short_term_memory'
 require_relative 'rcrewai/memory/long_term_memory'
 require_relative 'rcrewai/memory/entity_memory'
+require_relative 'rcrewai/memory/llm_entity_extractor'
 require_relative 'rcrewai/memory/tool_memory'
 require_relative 'rcrewai/rate_limiter'
 require_relative 'rcrewai/context_window'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcrewai
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - gkosmo
@@ -357,6 +357,7 @@ files:
 - docs/superpowers/plans/2026-05-11-llm-modernization.md
 - docs/superpowers/specs/2026-05-11-llm-modernization-design.md
 - docs/superpowers/specs/2026-07-06-cognitive-memory-design.md
+- docs/superpowers/specs/2026-07-07-consensual-process-design.md
 - docs/tutorials/advanced-agents.md
 - docs/tutorials/custom-tools.md
 - docs/tutorials/deployment.md
@@ -366,8 +367,10 @@ files:
 - docs/upgrading-to-0.3.md
 - docs/upgrading-to-0.4.md
 - docs/upgrading-to-0.6.md
+- docs/upgrading-to-0.7.md
 - examples/async_execution_example.rb
 - examples/cognitive_memory_example.rb
+- examples/consensual_process_example.rb
 - examples/flow_example.rb
 - examples/hierarchical_crew_example.rb
 - examples/human_in_the_loop_example.rb
@@ -413,6 +416,7 @@ files:
 - lib/rcrewai/memory/base_memory.rb
 - lib/rcrewai/memory/entity_memory.rb
 - lib/rcrewai/memory/in_memory_store.rb
+- lib/rcrewai/memory/llm_entity_extractor.rb
 - lib/rcrewai/memory/long_term_memory.rb
 - lib/rcrewai/memory/short_term_memory.rb
 - lib/rcrewai/memory/sqlite_store.rb