You can deploy this model and start earning money today!

theuveskhan/
swarmcore

Name: swarmcore
Availability: InStock

Views

No views yet

🐝 SwarmCore — Multi-Agent Swarm Intelligence Framework

A Colab-friendly multi-agent swarm system with zero GPU requirements — runs entirely on HuggingFace Inference API.

Features

Feature	Description
Multi-Agent Personas	Diverse analytical perspectives with tunable adversarial tension (0=cooperative, 1=adversarial)
Integrated RAG Pipeline	Ground analysis in your own documents (FAISS + sentence-transformers, ~130MB)
Autonomous Prompt Optimization	"Autoresearch" loop that self-optimizes agent personas via AI-judge feedback (OPRO + ProTeGi)
Human-In-The-Loop (HITL)	Take control between rounds: redirect focus, inject knowledge, toggle agents, modify prompts
Real-Time Streaming	Live SSE-style execution updates (terminal, notebook, and web-compatible)
Synthesis Reports	Auto-generated technical reports with Mermaid diagram visualizations
Swarm Score	0-100 quality metric across specificity, adversarial tension, convergence, and signal quality

Architecture

┌─────────────────────────────────────────────────────────────┐
│                      SwarmCore Engine                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       │
│  │ Agent 1  │  │ Agent 2  │  │ Agent 3  │  │ Agent N  │     │
│  │ Analyst  │  │ Critic   │  │ Expert   │  │ Synth.   │     │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
│       └──────────────┴──────┬───────┴──────────────┘        │
│                             │                               │
│  ┌──────────┐    ┌─────────▼─────────┐    ┌──────────┐     │
│  │   RAG    │◄───│   Swarm Engine     │───►│  Stream   │    │
│  │ Pipeline │    │  (Round Manager)   │    │  (SSE)    │    │
│  └──────────┘    └─────────┬─────────┘    └──────────┘     │
│                            │                                │
│              ┌─────────────┼─────────────┐                  │
│              │             │             │                   │
│  ┌───────────▼──┐  ┌──────▼───────┐  ┌─▼────────────┐     │
│  │  AI Judge    │  │ Autoresearch  │  │    HITL       │     │
│  │ (Swarm Score)│  │   (OPRO +     │  │  Controller   │     │
│  │  0-100       │  │   ProTeGi)    │  │              │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                             │
│  ┌──────────────────────────────────────────────────┐       │
│  │           Synthesis Report Generator              │      │
│  │  (Markdown + Mermaid Diagrams + Score Tracking)   │      │
│  └──────────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────────┘

Quick Start (Google Colab)

python

!pip install -q openai faiss-cpu sentence-transformers numpy

# Clone the repo
!git clone https://huggingface.co/theuveskhan/swarmcore
%cd swarmcore

import os
os.environ['HF_TOKEN'] = 'your-token-here'

from swarmcore import Swarm, Agent, AgentPersona, SwarmConfig
from swarmcore.llm import LLMClient, LLMConfig
from swarmcore.judge import SwarmJudge
from swarmcore.streaming import SwarmStream

# Setup LLM (no GPU needed — uses HF Inference API)
llm = LLMClient(LLMConfig(model='Qwen/Qwen2.5-72B-Instruct', provider='novita'))

# Define agents with different personas
agents = [
    Agent(AgentPersona(name='Analyst', role='Strategic Analyst',
        system_prompt='You analyze through economic and systems-thinking lenses.',
        contentious_level=0.4), llm),
    Agent(AgentPersona(name='Critic', role="Devil's Advocate",
        system_prompt='You stress-test every assumption and find counter-evidence.',
        contentious_level=0.9), llm),
    Agent(AgentPersona(name='Synthesizer', role='Synthesis Lead',
        system_prompt='You weave perspectives into actionable conclusions.',
        contentious_level=0.2), llm),
]

# Run the swarm with AI judge and streaming
judge = SwarmJudge(llm=llm)
stream = SwarmStream(mode='terminal')

swarm = Swarm(agents=agents, llm=llm, judge=judge,
    config=SwarmConfig(max_rounds=3))
swarm.add_callback(stream.callback)

results = swarm.run("What are the implications of AI agents for software engineering?")

Key Concepts

Concept	Description
Round	One cycle where all active agents provide their analysis
Convergence	Agents' positions align — detected via score plateau, majority agreement, or max rounds
Swarm Score	0-100 metric: specificity (0-25) + adversarial tension (0-25) + convergence (0-25) + signal quality (0-25)
Autoresearch	Autonomous loop that iterates on agent prompts, keeping changes that improve the Swarm Score
HITL	Human controls between rounds: continue, stop, redirect focus, inject knowledge, toggle agents, modify prompts

Modules

Module	Class	Description
`swarmcore.agent`	`Agent`, `AgentPersona`	Individual agents with persona, memory, analysis
`swarmcore.swarm`	`Swarm`, `SwarmConfig`	Orchestrator with rounds, convergence, RAG
`swarmcore.rag`	`RAGPipeline`	FAISS + sentence-transformers retrieval
`swarmcore.judge`	`SwarmJudge`, `SwarmScore`	AI judge scoring (G-Eval + CRIT)
`swarmcore.autoresearch`	`AutoresearchLoop`	Prompt optimization (OPRO + ProTeGi)
`swarmcore.hitl`	`HITLController`	Human-in-the-loop controls
`swarmcore.streaming`	`SwarmStream`	SSE-style streaming (terminal, notebook, web)
`swarmcore.report`	`SynthesisReport`	Report generation with Mermaid diagrams
`swarmcore.llm`	`LLMClient`, `LLMConfig`	OpenAI-compatible LLM interface

Research Foundation

Multi-Agent Debate: Du et al. (2023) "Improving Factuality and Reasoning through Multiagent Debate" — 67→82% accuracy
AI Judge (G-Eval): Liu et al. (2023) — 85% agreement with human experts via CoT scoring
CRIT Scoring: SocraSynth (2024) — contentious_level parameter for adversarial tension control
Prompt Optimization (OPRO): Google DeepMind (2023) — ascending history meta-prompt, +8% on GSM8K
Textual Gradients (ProTeGi): Microsoft (2023) — gradient→edit cycle, +31% over initial prompts

Requirements

openai>=1.0
faiss-cpu
sentence-transformers
numpy

License

MIT