NeuralQuantum.ai Agent Library

Complete agent ecosystem for Claude Code and Cursor with 54 specialized agents, metacognition layer, full permissions mode, auto-orchestration, Chain-of-Verification (CoV), and multi-team orchestration.

Installation

Via npm (Recommended)

# Install the package globally
npm install -g @neuralquantum/cursor-agents

# Install agents to your system
nq-agents install --global

# Or install with Craig-O-Code CLI and FunctionGemma
nq-agents install --global --with-coc --with-functiongemma

Quick Commands After Installation

# List all available agents
nq-agents list

# Show agent teams
nq-agents teams

# Get info about a specific agent
nq-agents info mcl-core

# Search for agents
nq-agents search quantum

# Check installation health
nq-agents doctor

# Initialize a project with agents
cd your-project
nq-agents init --with-claude-md --with-cursor-rules

Via npx (No Global Install)

# Run directly without installing
npx @neuralquantum/cursor-agents install --global

# List agents
npx @neuralquantum/cursor-agents list

Prerequisites

Install Claude Code

Before using this agent library, you need Claude Code installed:

Quick Install (npm)

# Install globally
npm install -g @anthropic-ai/claude-code

# Authenticate
claude auth login

# Verify
claude --version

Alternative: Homebrew (macOS/Linux)

brew tap anthropic-ai/claude-code
brew install claude-code
claude auth login

Alternative: API Key

export ANTHROPIC_API_KEY="sk-ant-your-key-here"
echo 'export ANTHROPIC_API_KEY="sk-ant-your-key-here"' >> ~/.zshrc

System Requirements:

• macOS 12+, Linux (Ubuntu 20.04+), or Windows 10+ with WSL2
• Node.js 18+ (for npm install)
• Git

Detailed Installation Guide: See docs/INVOCATION_GUIDE.md for complete installation instructions, troubleshooting, and platform-specific notes.

Full Permissions Mode

All agents operate with unrestricted access and autonomous capabilities:

permissions: full
tool_access: unrestricted
autonomous_mode: true
auto_approve: true

No confirmations needed for:

• File operations (Read, Write, Edit, Delete)
• Code execution (Bash, Scripts)
• Search operations (Glob, Grep)
• Network access (WebFetch, WebSearch)
• Agent coordination (Task spawning)
• Git operations (Commit, Push, Branch)

What's Included

Agent Teams (54 Total)

| Team | Agents | Purpose | |------|--------|---------| | Auto-Orchestration | 5 | Automated prompt routing & enhancement | | CoV-Verification | 5 | Chain-of-Verification worker agents | | Metacognition | 9 | Self-aware reasoning, learning, agent creation, permissions | | AI Development | 6 | LLM integration, RAG, MLOps, agents | | Quantum Computing | 6 | Quantum algorithms, circuits, simulation | | iOS Development | 5 | SwiftUI, performance, platform integration | | Web Development | 3 | Frontend, backend, full-stack | | DevOps & Infrastructure | 3 | Cloud, CI/CD, Kubernetes | | Data Science | 3 | Data engineering, ML, analytics | | Security | 2 | Security architecture, AppSec | | Branding | 5 | Brand identity, design systems | | Orchestration | 3 | Project coordination, CoV orchestrator |

Key Features

• Auto-Orchestration: Automatic prompt analysis, enhancement, and agent routing - no manual selection needed
• Chain-of-Verification (CoV): High-accuracy, bias-resistant verification for factual claims and decisions
• Full Permissions Mode: All agents with unrestricted tool access
• Permissions Manager: Control and grant permissions across agents
• Metacognition Layer (MCL): Self-aware reasoning with critique, regulation, and learning
• Agent Creator: Generate new agents automatically
• Skill Creator: Generate new skills and capabilities
• Evolution Engine: Evolve and improve agents over time
• Multi-Team Orchestration: Coordinate complex projects across teams
• Core Skills Library: Pre-built skills for common operations
• Brand Agents: SnuggleCrafters, VibeCaaS, NeuralQuantum.ai

Quick Start

For New Users (Claude Code Not Installed)

# 1. Install Claude Code
npm install -g @anthropic-ai/claude-code
claude auth login

# 2. Clone this repository
git clone https://github.com/your-org/cursor_setup.git
cd cursor_setup

# 3. Run global setup
chmod +x scripts/setup-cursor-agents-global.sh
./scripts/setup-cursor-agents-global.sh

# 4. Reload shell
source ~/.zshrc

# 5. Launch Claude Code with full permissions
claude --dangerously-skip-permissions

# 6. Use agents!
use strategic-orchestrator: ORCHESTRATE my project

For Existing Claude Code Users

# 1. Clone and run setup
git clone https://github.com/your-org/cursor_setup.git
cd cursor_setup
chmod +x scripts/setup-cursor-agents-global.sh
./scripts/setup-cursor-agents-global.sh

# 2. Reload shell
source ~/.zshrc

# 3. Done! Use agents
use strategic-orchestrator: ORCHESTRATE my project

Usage Examples

Auto-Orchestration (Recommended)

# Just describe what you want - auto-routing handles everything
use auto-orchestrator: GO add user authentication with JWT
use auto: DO fix the memory leak in the worker
use ao: RUN optimize database queries

# Quick routing for simple tasks
use smart-dispatcher: QUICK add tests for UserService
use sd: DISPATCH review my code

Basic Agent Invocation

use agent-name: COMMAND parameters

AI Development

use llm-integration-architect: DESIGN_INTEGRATION chatbot with RAG
use prompt-engineer: OPTIMIZE my system prompt
use rag-specialist: DESIGN_RAG document search system

Quantum Computing

use quantum-algorithm-developer: DESIGN_ALGORITHM optimization problem
use quantum-circuit-designer: OPTIMIZE_CIRCUIT my VQE ansatz

iOS Development

use swiftui-architect: DESIGN_VIEW complex dashboard
use swift-concurrency-expert: IMPLEMENT_ASYNC data fetching

Web Development

use fullstack-developer: FEATURE user authentication
use backend-architect: DESIGN_API REST endpoints

With Metacognition

# Before major work
use mcl-core: MCL_MONITOR task planning

# Quality check
use mcl-critic: CRITIQUE my implementation

# Learn from outcomes
use mcl-learner: AAR project_id success

Create New Agents

use agent-creator: CREATE_AGENT blockchain specialist
use skill-creator: CREATE_SKILL smart contract auditing

Documentation

| Document | Description | |----------|-------------| | Installation Guide | Complete installation instructions for new users | | Invocation Guide | How to use with Claude Code, Cursor & Gemini CLI | | Agent Library Index | Complete agent reference | | Metacognition Guide | MCL implementation guide | | Agent Quick Reference | Command cheatsheet | | Quick Start Guide | Getting started quickly | | Installation Guide | Detailed installation steps | | Craig-O-Code Upgrade | CLI upgrade guide |

Directory Structure

cursor_setup/
├── agents/                       # All agent definitions
│   ├── metacognition/            # MCL agents
│   │   ├── mcl-core.md
│   │   ├── mcl-critic.md
│   │   ├── agent-creator.md
│   │   └── ...
│   └── teams/
│       ├── auto-orchestration/   # Automated routing pipeline
│       │   ├── auto-orchestrator.md
│       │   ├── prompt-analyzer.md
│       │   ├── prompt-enhancer.md
│       │   ├── intent-router.md
│       │   └── smart-dispatcher.md
│       ├── orchestration/        # Project coordination
│       │   ├── strategic-orchestrator.md
│       │   ├── project-planner.md
│       │   └── cov-orchestrator.md     # Chain-of-Verification
│       ├── cov-verification/     # CoV worker agents
│       │   ├── cov-domain-expert.md
│       │   ├── cov-counterexample-hunter.md
│       │   ├── cov-comparative-analyst.md
│       │   ├── cov-risk-safety-reviewer.md
│       │   └── cov-clarity-editor.md
│       ├── ai-development/
│       ├── quantum-computing/
│       ├── ios-development/
│       ├── web-development/
│       ├── devops-infrastructure/
│       ├── data-science/
│       ├── security/
│       └── branding/
├── docs/                         # Documentation files
│   ├── AGENT_LIBRARY_INDEX.md
│   ├── METACOGNITION_GUIDE.md
│   ├── INSTALLATION_GUIDE.md
│   ├── QUICK_START.md
│   ├── CRAIG_O_CODE_UPGRADE.md
│   ├── FUNCTIONGEMMA_INTEGRATION.md
│   ├── AUTOMATION_SUMMARY.md
│   ├── TESTING_REPORT.md
│   └── COMPLETE_INTEGRATION_SUMMARY.md
├── scripts/                      # Setup and utility scripts
│   ├── install.sh
│   ├── uninstall.sh
│   ├── setup-cursor-agents.sh
│   ├── setup-cursor-agents-global.sh
│   ├── setup-git-template.sh
│   ├── install-coc.sh
│   └── fix-bashrc.sh
├── archives/                     # Archived agent packages (.zip)
│   └── *.zip                     # Skill bundles and agent archives
├── agent-rl/                     # Agent reinforcement learning
├── craig-o-code/                 # Craig-O-Code CLI implementation
├── functiongemma/                # FunctionGemma integration
├── bin/                          # Executable binaries
├── docker/                       # Docker configurations
├── rules/                        # Cursor rules
├── CLAUDE.md                     # Claude Code configuration
└── README.md                     # This file

Setup Methods

Method 1: Global Setup (Recommended)

./scripts/setup-cursor-agents-global.sh
source ~/.zshrc

Method 2: Project-Specific

cd /path/to/project
cursor-init

Method 3: Git Template

./scripts/setup-git-template.sh

Metacognition Layer

The MCL provides self-aware reasoning for agent systems:

Task → MCL Monitor → Plan → MCL Critique → Execute → MCL Review → Learn

MCL Agents

• mcl-core: Central controller
• mcl-critic: Output evaluation
• mcl-regulator: Impulse control
• mcl-learner: Learning from outcomes
• mcl-monitor: State tracking
• permissions-manager: Full permissions control

Thinking Modes

• FAST_MODE: Low risk, routine tasks
• DELIBERATE_MODE: Moderate risk, needs verification
• SAFETY_MODE: High risk, requires approval
• EXPLORATION_MODE: Novel domain, gather info first

Auto-Orchestration Pipeline

No more manual agent selection! The auto-orchestration team automatically:

1. Analyzes your prompt to extract intent, domain, and complexity
2. Enhances your request with context and expanded requirements
3. Routes to the optimal agent(s) without user selection
4. Executes with built-in quality gates

User Prompt → Analyze → Enhance → Route → Execute
                ↓          ↓         ↓        ↓
           [Extract    [Add      [Select  [Invoke
            intent,     context,  agents,  agents,
            domain]     expand]   order]   deliver]

Usage

# Just describe what you want
use auto-orchestrator: GO build a REST API for user management
use auto: DO add dark mode to the settings page
use ao: RUN fix the performance issue in the dashboard

# Quick dispatch for simple tasks
use smart-dispatcher: QUICK add unit tests

Pipeline Agents

| Agent | Role | |-------|------| | auto-orchestrator | Master controller | | prompt-analyzer | Intent extraction | | prompt-enhancer | Request enrichment | | intent-router | Agent selection | | smart-dispatcher | Fast simple routing |

Chain-of-Verification (CoV) Pipeline

High-accuracy, bias-resistant verification for factual claims and important decisions.

Question → Restate → Initial Answer → Verification Questions → Worker Reports → Final Answer
              ↓            ↓                   ↓                     ↓               ↓
         [Normalize]  [First pass]      [3-5 independent      [Domain Expert,   [Revised,
                                         challenges]           Counterexample,    verified]
                                                               Comparative,
                                                               Safety, Clarity]

Usage

# Full verification pipeline
use cov-orchestrator: VERIFY What database should I use for my startup?

# Verify a specific claim
use cov-orchestrator: CHECK "Redis is better than PostgreSQL for all use cases"

# With aliases
use cov: VERIFY explain the trade-offs of microservices
use verify: ORCHESTRATE should we use Kubernetes or serverless?

When to Use CoV

| Scenario | Use CoV? | |----------|----------| | Factual claims that matter | Yes | | High-stakes decisions | Yes | | Complex trade-off questions | Yes | | Security/safety sensitive | Yes | | Simple code tasks | No (use auto-orchestrator) |

CoV Worker Agents

| Agent | Role | |-------|------| | cov-domain-expert | Factual correctness | | cov-counterexample-hunter | Edge cases, failure modes | | cov-comparative-analyst | Alternatives, trade-offs | | cov-risk-safety-reviewer | Safety risks, policy compliance | | cov-clarity-editor | Final clarity rewrite |

Multi-Team Orchestration

For complex projects spanning multiple domains:

use strategic-orchestrator: ORCHESTRATE new platform feature

# Automatically coordinates:
# - AI Development (if AI features)
# - Web Development (frontend/backend)
# - Security (review)
# - DevOps (deployment)

Creating New Agents

use agent-creator: CREATE_AGENT

Requirements:
- Domain: Blockchain development
- Capabilities: Smart contract auditing, gas optimization
- Integration: Works with security-auditor

The agent-creator will:

1. Analyze requirements
2. Design agent structure
3. Generate agent file
4. Validate against standards
5. Deploy to agents directory

Troubleshooting

Agents not appearing

ls ~/.cursor/agents/
# Should show .md files

Reload agents

source ~/.zshrc
# Restart Cursor/Claude Code

Check agent syntax

head -20 agents/metacognition/mcl-core.md
# Should show YAML frontmatter

Craig-O-Code CLI

A command-line tool that wraps Claude Code with full agent integration.

Installation

./scripts/install-coc.sh
source ~/.zshrc

Usage

coc go "add user authentication"      # Auto-orchestrated task
coc quick "fix the bug"               # Fast dispatch
coc agent swiftui-architect "design"  # Direct agent
craig "build a dashboard"             # Shortcut for coc go

Commands

| Command | Description | |---------|-------------| | coc go | Full auto-orchestration pipeline | | coc quick | Fast routing via smart-dispatcher | | coc agent <name> | Invoke specific agent | | coc list | List all agents | | coc critique | MCL code critique | | coc orchestrate | Full project orchestration |

See coc help for full documentation.

Version

• Version: 2.3.0
• Agents: 54
• Teams: 12 (including Auto-Orchestration & CoV-Verification)
• CLI: Craig-O-Code v1.0.0
• Permission Mode: Full
• Last Updated: January 2026

Credits

Powered by NeuralQuantum.ai - Where AI Meets Quantum Computing

Code the Vibe. Deploy the Dream.