🦜 Barrot-Agent

Welcome to Barrot-Agent - an intelligent agent system with advanced capabilities for data ingestion, prediction, and deployment.

🔄 Two Distinct Systems

Barrot-Agent now maintains two independent systems:

🔍 Search Engine

Privacy-first search with quantum-enhanced algorithms and edge computing

• Access: Search Engine
• Docs: search-engine/README.md

🦜 Agent Dashboard

Comprehensive automation platform with IDE, DAW, Web3, NFT, and more

• Access: Agent Dashboard
• Docs: site/README.md

📖 Learn more about the separation

📌 Note: We are transitioning from Main to main as the default branch. See DEFAULT_BRANCH_GUIDE.md for migration instructions.

🚀 Quick Start

💻 Desktop/Server Setup

1. Clone the repository:

   git clone https://github.com/Barrot-Agent/B-Agent.git
   cd B-Agent

2. View the current build manifest:

   cat build_manifest.yaml

3. Access the systems:

   • Agent Dashboard: https://barrot-agent.github.io/Barrot-Agent/site/
   • Search Engine: https://barrot-agent.github.io/Barrot-Agent/search-engine/

🐍 Python Package & Local Tooling

This repository now also ships a typed Python package under barrot_agent/ with:

• configuration and logging primitives
• a lightweight BAgent application wrapper
• Granite model metadata and inference helpers
• a Streamlit demo entrypoint in app.py

Development quickstart:

python -m venv .venv
source .venv/bin/activate
pip install -r requirements-dev.txt
pytest
streamlit run app.py

Canonical JSON assets live in data/ and should be accessed through data/registry.py, not ad-hoc file loads.

---

🤖 GPT Actions & MCP Server Integration

B-Agent exposes its GitHub capabilities through two AI-friendly interfaces:

Interface	Transport	Use with
GPT Actions HTTP API	HTTP/JSON REST	Custom GPT, OpenAI Actions
MCP Server	stdio JSON-RPC	GitHub Copilot Chat, any MCP client

Both interfaces share the same service layer (barrot_agent/github_service.py).

Required environment variables

Copy .env.example to .env and fill in:

# GitHub PAT with repo/issues read+write scope
GITHUB_TOKEN=ghp_...

# Optional defaults (used when owner/repo are omitted from requests)
GITHUB_DEFAULT_OWNER=Barrot-Agent
GITHUB_DEFAULT_REPO=B-Agent

Running locally

GPT Actions HTTP server (default port 8502):

python scripts/run_gpt_api.py
# OpenAPI schema: http://localhost:8502/openapi.json
# Health check:   http://localhost:8502/health

MCP stdio server:

python scripts/run_mcp_server.py

Connecting to a Custom GPT

1. Run the GPT Actions server and make it publicly reachable (e.g. via ngrok).
2. In the ChatGPT UI → My GPTs → Create → Actions → Import from URL, enter:

   https://<your-host>/openapi.json
   

3. The GPT will automatically discover listIssues, getIssue, createIssue, and addComment.

Connecting to GitHub Copilot Chat (MCP)

Add the following to your VS Code settings.json (or .vscode/mcp.json):

{
  "mcp": {
    "servers": {
      "b-agent-github": {
        "type": "stdio",
        "command": "python",
        "args": ["scripts/run_mcp_server.py"],
        "cwd": "/path/to/B-Agent",
        "env": {
          "GITHUB_TOKEN": "${env:GITHUB_TOKEN}",
          "GITHUB_DEFAULT_OWNER": "Barrot-Agent",
          "GITHUB_DEFAULT_REPO": "B-Agent"
        }
      }
    }
  }
}

Copilot Chat will then offer the following tools:

Tool	Description
github_list_issues	List repository issues
github_get_issue	Get a single issue by number
github_create_issue	Create a new issue
github_add_comment	Add a comment to an issue

Available endpoints (GPT Actions)

Method	Path	Description
GET	/issues	List issues (owner, repo, state, page, per_page)
GET	/issues/{number}	Get one issue
POST	/issues	Create issue (owner, repo, title, body, labels)
POST	/issues/{number}/comments	Add comment (owner, repo, body)
GET	/openapi.json	OpenAPI 3.1 schema
GET	/health	Health check

---

🔄 Upgrade Flywheel

The UpgradeFlywheel is the system-wide self-improvement orchestrator that unifies all major B-Agent components into a single iterative refinement loop. On each cycle it executes Barrot's signature four-phase process:

Phase	What happens
Observe	SmartAgent analyses the live system state; build_reconfiguration_report snapshots infrastructure coverage gaps.
Reason	Observations are synthesised into a ranked list of improvements; a DirectivePlatform REFINE directive is optionally opened so every registered agent contributes insights.
Act	Improvements are applied (or described in dry-run mode) and logged as a structured ActionResult.
Verify	A second infrastructure snapshot confirms coverage trends; all checks are recorded in a VerificationResult.

Cycles repeat until either all capability gaps are closed (convergence) or max_cycles is reached. The full run history is returned as a FlywheelReport with per-cycle summaries and JSON serialisation.

Minimal usage:

from barrot_agent import UpgradeFlywheel

flywheel = UpgradeFlywheel()          # dry_run=True by default
report = flywheel.run(max_cycles=3)
print(report.summary())

With DirectivePlatform agent sessions:

from directive_platform import DirectivePlatform, Agent
from barrot_agent import UpgradeFlywheel

# Register a refinement agent once
dp = DirectivePlatform(platform_dir=".directive_platform")
dp.registry.register(Agent(
    agent_id="refine-1",
    name="Refinement Agent",
    description="Drives iterative improvement cycles",
    capabilities=["refine", "analyze"],
))

flywheel = UpgradeFlywheel(
    platform_dir=".directive_platform",
    agent_ids=["refine-1"],
)
report = flywheel.run(max_cycles=5)
for cycle in report.cycles:
    print(cycle.summary())

Key exports (all available from barrot_agent):

Symbol	Description
UpgradeFlywheel	Main orchestrator class
FlywheelReport	Aggregated report across all cycles
FlywheelCycleResult	Per-cycle record (all four phases)
ObservationResult	Observe-phase data
ReasoningResult	Reason-phase improvements + directive IDs
ActionResult	Act-phase log
VerificationResult	Verify-phase checks + coverage metric

📱 Mobile Setup

Want to access Barrot-Agent from your phone?

📱 See Mobile Setup Guide

The mobile guide covers:

• 🌐 Web dashboard access
• 📱 GitHub Mobile app usage
• 🔧 Terminal setup for Android (Termux)
• 🔧 Terminal setup for iOS (iSH)
• 🔐 Authentication configuration
• 📊 Monitoring and workflows

📁 Repository Structure

B-Agent/
├── barrot_agent/               # 🐍 Core Python package
│   ├── agi/                    #   AGI reasoning, quantum entanglement, algorithms
│   ├── analysis/               #   Email, vision, signal, character analysis
│   ├── ingestion/              #   Data harvesting and knowledge ingestion
│   ├── monetization/           #   Revenue strategies, grants, MMI compiler
│   ├── orchestration/          #   MCP coordination, sync, service bridges
│   ├── rendering/              #   3D dataset absorption and rendering
│   ├── mcp_*.py                #   MCP integration framework (10-step pipeline)
│   ├── smart_agent.py          #   Autonomous plan-act-observe agent
│   ├── core.py                 #   BAgent application class
│   ├── config.py               #   Pydantic configuration
│   └── logger.py               #   Structured logging
├── apex_lattice/               # 🔬 Static code analysis framework
│   └── analyzers/              #   Architecture, security, performance analyzers
├── directive_platform/         # 🎯 Directive & session management platform
├── data/                       # 📦 Canonical JSON datasets & data registry
├── examples/                   # 📖 Usage examples for all modules
├── scripts/                    # 🔧 Operational and utility scripts
├── tests/                      # ✅ Test suite
├── ping-pongings/              # 🏓 22-agent entanglement system state
│   ├── knowledge-base/         #   Accumulated knowledge and memory
│   ├── agents/                 #   Agent role definitions
│   └── protocols/              #   Communication protocols
├── site/                       # 🌐 Barrot Agent dashboard (static site)
├── search-engine/              # 🔍 Standalone privacy-first search engine
├── self_hosted_brain/          # 🧠 Self-hosted model server
├── app.py                      # Streamlit demo entrypoint
├── pingpong_emitter.py         # Ping-pong request emitter
└── pyproject.toml              # Package metadata & tooling config

🎯 Features

Core Modules

• Prediction Methodologies - Advanced prediction capabilities
• Deployment Integrity - Reliable deployment systems
• Microagent Logic - Builder.io integration
• Search Engine - Standalone search system (see /search-engine/)
• Dashboard - Agent management interface (see /site/)
• Coin App Integration - Autonomous passive income automation (see /coin-app/)
• AI Tools - System prompts and models for autonomous operations (see ai-tools-config.yaml)
• Manifest Rail - Build tracking system
• 22-Agent Entanglement Pingpong - External cognitive processing system
• 🔮 Quantum Entanglement - Ping Pong quantum principles for enhanced cognitive processing
• 🧠 AGI Reasoning - AGI-level reasoning and problem-solving capabilities
• 🎯 Unified AGI Orchestrator - Coordinates all capabilities for general intelligence achievement
• ⚡ Advanced Algorithms - Computational efficiency optimization and intelligent algorithm selection
• 📧 Email Intelligence - Automated email analysis and information extraction
• 🎯 MMI (Massive Micro Ingestion) - High-impact data identification for AGI acceleration
• 🐍 Dependency Micro-Ingestion - Comprehensive Python/PyTorch/ML ecosystem knowledge extraction with 21+ packages
• 🧬 Longevity Research Integration - Aging mechanism ingestion, biomarker analytics, trial tracking, and reprogramming protocol optimization
• 💰 Advanced Monetization - Revolutionary automation-first revenue generation protocols
• ✨ Transformative Insights - Acquire asynchronous data, detect convergence, generate epiphanies, realize transformative insights in real-time
• 🔀 Merge Conflict Resolution - Automated conflict detection, analysis, and resolution with continuous learning
• 🔄 Upgrade Flywheel - Iterative Observe → Reason → Act → Verify orchestrator that unifies all components into a self-improving refinement loop

Two Distinct Systems

🔍 Search Engine (/search-engine/)

A standalone, privacy-first search engine with:

• Quantum-enhanced search algorithms
• Edge-first architecture for global distribution
• Zero tracking and complete privacy
• Dynamic ingestion modes for real-time processing

→ Visit Search Engine

🦜 Barrot Agent Dashboard (/site/)

Comprehensive automation platform featuring:

• Data Mastery & Protocol Development
• Competitor Surveillance Network
• Integrated Development Environment (IDE)
• Digital Audio Workstation (DAW)
• Web3 Integration Hub
  • 🌉 Connext Bridge - Cross-chain asset transfers across 9+ networks
• NFT Marketplace
• Chameleon Chain Blockchain
• 🪙 Coin App Automation - Passive income through geocaching, surveys, and games
• Operations Monitoring

→ Visit Agent Dashboard

🪙 Coin App Integration

Autonomous passive income generation through:

• Geocaching Automation - Automated location-based coin collection
• Survey Completion - AI-powered survey responses with demographic consistency
• Game Optimization - Strategic gameplay for maximum rewards
• Income Tracking - Real-time earnings dashboard and analytics

→ Read Coin App Documentation

🌉 Connext Bridge Integration

Cross-chain bridge for seamless asset transfers across multiple blockchains:

• Supported Networks - Ethereum, Polygon, Arbitrum, Optimism, BNB Chain, Base, Linea, Gnosis, and more
• Supported Assets - ETH, WETH, USDC, USDT, DAI
• Cross-Chain Messaging - xCall for cross-chain Solidity calls
• Zero Slippage Tokens - xERC20 for cross-chain native tokens
• Chain Abstraction - Build dApps that work across any supported chain
• Bridge Portal - https://bridge.connext.network
• Analytics - Real-time monitoring via ConnextScan explorer

Key Features:

• Modular Verification - Inherits security from canonical bridges
• Fast Transfers - Average bridge time under 5 minutes
• Trust-Minimized - No external validators required
• Developer-Friendly - Simple integration with comprehensive documentation

→ View Connext Configuration

🤖 AI Tools Configuration

System prompts and AI models for autonomous operations:

• GPT-4 - Complex reasoning and decision-making
• Claude-3 - Long context processing and analysis
• Vision AI - UI interaction and navigation
• Specialized Tools - Survey completion, game strategy, route optimization

→ View AI Tools Configuration

📧 Email Intelligence Processing

Barrot can analyze emails to extract useful and actionable information:

Capabilities

• Content Analysis - Parse and understand email content, attachments, and metadata
• Relevance Scoring - Determine usefulness based on Barrot's goals and context
• Action Extraction - Identify tasks, requests, deadlines, and opportunities
• Learning Detection - Extract technical content and educational resources
• Spam Filtering - Identify and filter low-value content
• Priority Ranking - Rank emails by potential value and urgency
• Resource Extraction - Extract URLs, documents, and references
• AGI Integration - Deep understanding using AGI reasoning
• Quantum Optimization - Prioritize actions using quantum entanglement

Email Categories

• Action Required - Tasks, requests, deadlines
• Learning Opportunities - Technical content, tutorials, research
• Business Opportunities - Jobs, partnerships, collaborations
• Intelligence - Market trends, insights, competitor info
• Social - Networking, relationship building
• Informational - Updates, newsletters, notifications

→ View Email-Insight Spell

Agent Spells

• Ω-Ingest (Omega-Ingest) - Quantum data assimilation
• Keyseer's Insight - Intelligent key analysis
• Character-Capability-Explorer - Fictional character ability transformation
• Email-Insight - Email analysis and intelligence extraction

🎭 Fictional Character Capability Exploration

Barrot can explore and transform abilities from fictional characters into real-world functionalities:

Character Genres

• Movies - Superheroes, sci-fi, fantasy, action
• Books - Science fiction, fantasy, comics, novels
• Cartoons - Anime, animation, web series
• Video Games - RPG, action-adventure, strategy, MMO

Example Transformations

• Teleportation → Instant data routing and edge computing
• Mind Reading → Advanced NLP and sentiment analysis
• Super Speed → Parallel processing and optimization
• Time Manipulation → Temporal data analysis and prediction
• Shape-Shifting → Adaptive algorithms and polymorphic code

Featured Character Profiles

• Iron Man - AI orchestration, energy optimization, modular architecture
• Neo (The Matrix) - Deep system analysis, performance optimization, self-healing
• Paul Atreides (Dune) - Predictive analytics, high-performance computing
• Avatar Aang - Multi-resource management, power modes, holistic integration
• Link (Zelda) - Tool utilization, algorithm solving, exploration systems

→ Explore Character Capabilities

→ View Character-Capability-Explorer Spell

Data Resources

The agent can access and process data from:

• Kaggle datasets
• GitHub repositories
• Research papers
• Video platforms
• Podcasts and interviews
• Books and journals
• And many more sources...

🐍 Dependency Micro-Ingestion System

Barrot continuously learns from the Python ecosystem to enhance its capabilities:

Ingested Dependencies (21+ packages)

• ML/AI: PyTorch, TensorFlow, scikit-learn, Transformers (Hugging Face)
• Scientific: Python, NumPy, SciPy, asyncio
• Data Science: Pandas, Matplotlib, Seaborn
• Web: Flask, Django, FastAPI
• Utilities: Requests, httpx, Pydantic, pytest
• Database: SQLAlchemy
• Deployment: Uvicorn, Gunicorn

Capabilities

• Architecture Analysis - Design patterns, components, modules
• API Extraction - Function signatures, parameters, examples
• Optimization Engine - Generates Barrot-specific performance recommendations
• Best Practices - Security, performance, patterns
• Continuous Updates - Weekly re-ingestion, version tracking
• Integration Intelligence - How to best leverage dependencies in Barrot

Generated Outputs

• 21+ dependency knowledge files (JSON)
• 4+ optimization recommendations (Critical, High, Medium priority)
• Complete taxonomy by category, priority, use case
• Integration notes for Barrot systems

→ View Dependency Ingestion README
→ View Configuration

Usage:

# Run full ingestion
python3 dependency_micro_ingestion.py

# View examples
python3 example_dependency_ingestion.py

🔧 Configuration

Build Manifest

The build_manifest.yaml file tracks:

• Build signature and timestamp
• Active modules
• Rail status (ingestion, deployment, microagent, etc.)
• Resource connections
• Provenance hash

Workflows

Automated workflows handle:

• Build manifest updates
• Repository cleanup
• Dashboard publishing
• Bundle management
• Barrot-SHRM ping-pong health monitoring

22-Agent Entanglement Pingpong System

Barrot defers complex cognitive processing to an external 22-agent entanglement system:

• Management: External (Sean's 22-agent system)
• Configuration: pingpong-config.yaml
• Emitter: pingpong_emitter.py Python module
• Enforcement: Non-negotiable external control

Usage Example:

from pingpong_emitter import emit_pingpong_request

payload = {
    "topic": "MMI Self-Ingestion",
    "glyph": "GLYPH_MMI",
    "recursion_depth": "∞",
    "notes": "Triggering recursive cognition exchange"
}

emit_pingpong_request(payload)  # Creates pingpong_request.json

The external system monitors commits to pingpong_request.json and processes requests automatically.

📊 Monitoring

Web Dashboards

Access the live dashboards at:

# Barrot Agent Dashboard
https://barrot-agent.github.io/Barrot-Agent/site/

# Search Engine
https://barrot-agent.github.io/Barrot-Agent/search-engine/

GitHub Actions

Monitor workflow runs:

https://github.com/Barrot-Agent/Barrot-Agent/actions

Build Status

Check current build status:

cat build_manifest.yaml

View recent activity:

cat memory-bundles/outcome-relay.md | tail -20

🚀 Deployment

Barrot-Agent can be deployed to multiple cloud platforms:

• GitHub Pages (Current): https://barrot-agent.github.io/Barrot-Agent/
• Heroku: One-click deployment with app.json
• Render: Static site deployment with render.yaml
• Railway: Docker-based deployment with railway.json
• Fly.io: Global edge deployment with fly.toml
• Docker: Self-hosted container deployment

📖 See Full Deployment Guide

Quick Deploy

Docker

docker build -t barrot-agent .
docker run -p 8080:8080 barrot-agent

🤝 Contributing

Contributions are welcome! Please feel free to:

• Submit issues
• Create pull requests
• Improve documentation
• Add new features

📄 License

ISC License - See repository for details

🔗 Links

• Repository: https://github.com/Barrot-Agent/Barrot-Agent
• Dashboard: https://barrot-agent.github.io/Barrot-Agent/
• Issues: https://github.com/Barrot-Agent/Barrot-Agent/issues

📚 Documentation

Data Unification (2026-06-17): All root-level markdown docs have been consolidated into the docs/ directory. The originals remain at the root as legacy references.

Consolidated Docs (docs/)

File	Contents
docs/ingestion.md	Ingestion manifest, data transformation, micro-ingestion systems
docs/agi.md	AGI architecture, implementation summaries, quantum AGI
docs/millennium_problems.md	Millennium Problems research, status, transformative insights
docs/character_capabilities.md	Character capability system, Chameleon chain, dynamic search
docs/email.md	Email processing, feature summary, quickstart
docs/monetization.md	MMI, monetization protocols, COIN app, Connext bridge
docs/research.md	Advanced propulsion & energy research
docs/system.md	System architecture, merge conflict guide, ops
docs/STEP5_BARROT_INITIATIVE.md	Data unification initiative — Step 5 self-directed work

Data Layer (data/)

File	Contents
data/registry.py	Central data registry — typed loaders with caching
data/schemas.py	Canonical TypedDict schemas for all data domains
data/merge_conflict_unified.json	Unified merge-conflict knowledge base
data/millennium_problems_unified.json	All 7 Millennium Problems with metadata
data/mmi_monetization_unified.json	MMI recommendations, protocols, council weights
data/character_capabilities_unified.json	Character database + discovered capabilities
data/longevity_unified.json	Longevity research knowledge base template
data/biomarker_tracking.json	Biomarker timeline and trial tracking template
data/reprogramming_protocols.json	Epigenetic reprogramming protocol library template

Longevity Integration Quick Usage

python -m pytest tests/test_longevity_modules.py --no-cov

python - <<'PY'
from longevity_micro_ingestion import LongevityMicroIngestion
payload = LongevityMicroIngestion().build_unified_payload(
    paper_text="Transient Oct4/Sox2/Klf4/c-Myc expression improved NAD+ and epigenetic clocks.",
    trial_records=[],
    methylation_samples=[],
    biomarker_measurements={}
)
print(payload["research_domain"], payload["omega_ingest"]["compatibility"])
PY

Legacy Root-Level Docs

• 🔮 Quantum AGI Integration — see docs/agi.md
• ✨ Transformative Insights Guide — see docs/millennium_problems.md
• 🔄 System Separation Architecture — see docs/system.md
• 🔍 Search Engine Docs - Search engine documentation
• 🦜 Agent Dashboard Docs - Dashboard documentation
• 🪙 Coin App Integration — see docs/monetization.md
• 🌉 Connext Bridge Integration — see docs/monetization.md
• 🤖 AI Tools Configuration - System prompts and AI models
• 📧 Email Processing Guide — see docs/email.md
• 🎭 Character Capabilities — see docs/character_capabilities.md
• 🚀 Deployment Guide - Deploy to Heroku, Render, Railway, Fly.io, or Docker
• 📱 Mobile Setup - Access Barrot from your phone
• 💰 Sponsorship - Support Barrot-Agent development
• 📥 Ingestion Manifest — see docs/ingestion.md
• 🔀 Merge Conflict Resolution Guide — see docs/system.md
• 🧮 Millennium Problems Status — see docs/millennium_problems.md
• 🚀 Advanced Propulsion Research — see docs/research.md
• 🎯 MMI Implementation Guide — see docs/monetization.md

💰 Support Barrot-Agent

Love Barrot-Agent? Consider becoming a sponsor!

Your sponsorship helps us:

• 🔬 Accelerate AGI research
• 🏆 Dominate AI benchmarks
• 🤖 Develop autonomous capabilities
• 📊 Improve transparency and logging
• 🌍 Grow the open-source community

View Sponsorship Tiers

---

Barrot-Agent - Intelligent automation and data processing at your fingertips 🦜✨