Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement
Sign In

strray-ai

Package Overview
Dependencies
Maintainers
1
Versions
245
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

strray-ai

⚡ 0xRay: Self-Healing AI Governance OS - Enterprise AI orchestration for OpenCode, Hermes, and OpenClaw

latest
Source
npmnpm
Version
1.22.66
Version published
Weekly downloads
2.1K
311.18%
Maintainers
1
Weekly downloads
 
Created
Source

⚡ 0xRay: Self-Healing AI Governance OS

0xRay (StringRay) is now a first-class citizen inside the official Grok CLI — full plugin with real PreToolUse governance hooks, researcher + governance MCP servers, and the complete Dynamo Solar SSOT decision engine.

Install the plugin in one command:

npx strray-ai grok install

Then just use Grok normally. The full power of 0xRay (researcher, governance, skills) is available natively.

Enterprise AI Orchestration Framework for OpenCode, Hermes, and OpenClaw — by 0xRayAI

Version License Tests GitHub stars

Intelligent Multi-Agent Coordination with 99.6% Systematic Error Prevention

0xRay extends OpenCode, Hermes Agent, and OpenClaw with intelligent multi-agent orchestration, Codex compliance validation, and enterprise-grade security. It automatically routes tasks to specialized agents based on complexity and provides systematic error prevention across all three runtimes.

What is 0xRay?

0xRay is a one-command level-up for OpenCode. Instead of installing OpenCode first, then adding 0xRay, just run:

npx strray-ai install

This single command:

  • Detects if OpenCode is installed
  • Auto-installs OpenCode if missing
  • Layers on the full 0xRay kernel (Codex, orchestrator, enforcer, processors, MCP, reflections)
  • Installs 44 framework skills
  • Sets up the skills registry with 10 curated community sources
  • Adds CLI commands for agent publishing, skills management, and status

Goal: Any developer can run one command and instantly get a production-grade, governed agent runtime.

Who is it for?

  • Developers using OpenCode or Hermes who want AI-assisted development
  • Teams needing consistent code quality and error prevention
  • Enterprises requiring security, compliance, and audit capabilities

🚀 Quick Start

# Install 0xRay (auto-configures OpenCode on install)
npm install strray-ai

# That's it! 0xRay is now active.
# Restart OpenCode or Hermes to load the plugin.

What happens during install?

  • Copies OpenCode configuration files to your project
  • Configures 42 agents with proper capabilities
  • Sets up Codex enforcement rules
  • Enables webhook triggers for CI/CD integration
  • Ready to use with Hermes immediately

Standalone Mode (No OpenCode Required)

For use with Hermes Agent without OpenCode:

npx strray-ai install --standalone

This installs only the MCP servers - no OpenCode dependency.

✨ Features

  • 🤖 42 Specialized Agents - Autonomous agents that read/write code, run commands, and enforce compliance
  • 📏 99.6% Error Prevention - Universal Development Codex (60 terms)
  • ⚡ 44 Framework Skills + 10 curated community sources (170+ additional skills available)
  • 🛡️ Enterprise Security - Comprehensive validation and scanning
  • 📦 Skills Registry - Browse and install community skills from GitHub repos
  • 🔄 Complexity-Based Routing - Intelligent task delegation
  • 🔌 Webhook Integration - GitHub, GitLab, Bitbucket, Stripe
  • ✅ 2579 Tests - Production-ready with comprehensive test coverage
  • 🧩 Standalone MCP Servers - Works with Hermes Agent without OpenCode
  • 🌐 OpenClaw Integration - WebSocket bridge to OpenClaw gateway for chat orchestration

🤖 Available Agents

AgentPurposeStatus
@architectSystem design & technical decisionsActive
@security-auditorVulnerability detectionActive
@code-reviewerQuality assessmentActive
@refactorerTechnical debt eliminationActive
@testing-leadTesting strategy & coverageActive
@bug-triage-specialistError investigationActive
@researcherCodebase explorationActive

Note: 0xRay auto-configures all agents during installation. To customize agent settings, see the Agent Configuration Guide.

View all 42 agents →

📦 OpenClaw Integration

🤖 Grok CLI Integration (First-Class)

0xRay is now a first-class citizen inside the official Grok CLI (same depth as OpenCode).

  • Full plugin with hooks (PreToolUse for governance enforcement)
  • .mcp.json registration for strray-governance + strray-skills (researcher, etc.)
  • npx strray-ai grok install (auto-trust + project seeding)
  • Real Dynamo Solar SSOT governance running inside your Grok sessions

Install the plugin:

npx strray-ai grok install

Then just use Grok — the researcher and full governance system are now available natively.

🛡️ Governance System (Dynamo Solar SSOT)

0xRay ships a production-grade governance engine:

  • Dynamo Solar SSOT: Multi-factor decision matrix (resonance, isotopic ratio, vortex volume, historical coherence, solar activity)
  • Pure MCP transport (no simulation in modern paths)
  • Real proposal voting + apply with researcher deliberation
  • PreToolUse hooks that can enforce Codex before code changes

Governance is the heart of self-healing AI development.

See docs/governance/ and the governance-core.ts for the full matrix.

0xRay integrates with OpenClaw - a self-hosted AI gateway that connects messaging platforms (WhatsApp, Telegram, Discord, Slack) to AI coding agents.

What It Does

  • WebSocket Connection: Connect to OpenClaw Gateway at ws://127.0.0.1:18789
  • Skill Invocation: OpenClaw skills invoke 0xRay agents via HTTP API (port 18431)
  • Tool Events: Forward tool.before/tool.after events to OpenClaw for real-time tracking
  • Offline Buffering: Events queued when disconnected, sent on reconnect

Quick Setup

# Configure in .opencode/openclaw/config.json
{
  "gatewayUrl": "ws://127.0.0.1:18789",
  "authToken": "your-device-token",
  "deviceId": "your-device-id",
  "apiServer": { "enabled": true, "port": 18431 },
  "hooks": { "enabled": true, "toolBefore": true, "toolAfter": true }
}

# Initialize in code
import { initializeOpenClawIntegration } from 'strray-ai';
const integration = await initializeOpenClawIntegration();

See OpenClaw Integration Guide for details.

🔮 Hermes Agent Integration

0xRay's MCP servers work as native tools in Hermes Agent — a standalone AI coding agent with its own runtime, not dependent on OpenCode or Hermes. This gives you the full 0xRay toolset (code analysis, linting, security scanning, orchestration, state management) inside any Hermes session.

What You Get

Hermes discovers 10 0xRay MCP servers automatically. Each server exposes tools that Hermes can call directly — no prompts, no proxies, no agent delegation overhead.

MCP ServerTools ExposedWhat It Does
strray-architect-toolscodebase_structure, dependency_analysis, context_analysis, architecture_assessmentAnalyze project structure, dependencies, patterns, and architectural health
strray-auto-formatauto_format, format_checkPrettier + ESLint + TypeScript formatting and validation
strray-enforcerrule_validation, codex_enforcement, quality_gate_check, run_pre_commit_validationCodex compliance, quality gates, pre-commit validation
strray-estimationvalidate_estimate, start_tracking, complete_tracking, get_accuracy_reportTask estimation with calibration and accuracy tracking
strray-framework-helpstrray_get_capabilities, strray_get_commands, strray_explain_capabilityFramework reference, agent docs, capability lookups
strray-lintlint, lint_checkESLint validation with auto-fix and rule-specific checks
strray-orchestratororchestrate_task, analyze_complexity, get_orchestration_status, optimize_orchestration, cancel_orchestrationMulti-agent task planning, complexity scoring, parallel optimization
strray-researchersearch_codebase, find_implementation, get_documentationCodebase search, pattern finding, documentation lookup
strray-security-scansecurity_scan, dependency_auditVulnerability scanning and dependency audit
strray-state-managerget_state, set_state, delete_state, list_state, backup_state, restore_state, validate_statePersistent key-value state with backup/restore

Setup

  • Install 0xRay in your project:
npm install strray-ai
  • Add the MCP server entries to your Hermes config (~/.hermes/config.yaml):
mcp_servers:
  strray-architect-tools:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/architect-tools.server.js
    timeout: 30
  strray-auto-format:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/auto-format.server.js
    timeout: 30
  strray-enforcer:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/enforcer-tools.server.js
    timeout: 30
  strray-estimation:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/estimation.server.js
    timeout: 30
  strray-framework-help:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/framework-help.server.js
    timeout: 30
  strray-lint:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/lint.server.js
    timeout: 30
  strray-orchestrator:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/orchestrator/server.js
    timeout: 60
  strray-researcher:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/researcher.server.js
    timeout: 60
  strray-security-scan:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/security-scan.server.js
    timeout: 30
  strray-state-manager:
    command: node
    args:
      - ./node_modules/strray-ai/dist/mcps/state-manager.server.js
    timeout: 30
  • Restart Hermes. The tools will appear with the mcp_strray_ prefix.

Usage Examples

Once connected, Hermes can use the tools directly in conversation:

  • "Analyze this project's architecture and give me a health score"
  • "Run a security scan on the codebase"
  • "Lint all TypeScript files and auto-fix what you can"
  • "Plan a refactoring of the auth module — break it into steps"
  • "Track my time: I estimate this feature will take 2 hours"
  • "Search the codebase for all database query patterns"

How It Differs from OpenCode

OpenCode PluginHermes MCP
RuntimeOpenCode or Claude CodeAny Hermes session (CLI, Telegram, Discord)
DiscoveryPlugin injection via opencode.jsonMCP protocol via config.yaml
Tool AccessAgent-to-agent delegationDirect tool calls from Hermes
ContextShared OpenCode sessionFull Hermes session with memory
PlatformsTerminal onlyCLI, Telegram, Discord, WhatsApp, Slack

Tips

  • Use absolute paths in args if Hermes runs from a different working directory than your project
  • Increase timeout for orchestrator and researcher (60s) — they do heavier analysis
  • The state-manager persists to .strray/state/mcp-state.json — survives Hermes restarts
  • Auto-format and lint need Prettier/ESLint installed in your project to do real work (otherwise they report what's missing)

📖 Documentation

GuideDescription
Agent ConfigurationCopy-paste opencode.json agent setup
Configuration ReferenceComplete features.json settings
Agent DocumentationDetailed agent specifications
Universal Codex60-term codex reference
TroubleshootingCommon issues & solutions

🔧 CLI Tools

0xRay provides CLI utilities for managing and monitoring your installation:

# Core commands
npx strray-ai status              # Check configuration and plugin status
npx strray-ai validate            # Validate installation and dependencies
npx strray-ai capabilities       # Show all available features
npx strray-ai health             # Run health check on framework components
npx strray-ai report             # Generate usage and performance reports

# Agent management
npx strray-ai publish-agent --agent orchestrator  # Package agent for AgentStore

# Skills management
npx strray-ai skill:install              # Show starter packs + available sources
npx strray-ai skill:install agency-agents  # Install from registry (auto-detects format)
npx strray-ai skill:install <github-url>  # Install from any repo
npx strray-ai skill:registry list      # Show all registry sources
npx strray-ai antigravity status       # Show installed skills with licenses

Note: Installation is automatic via npm install strray-ai. The postinstall hook configures everything automatically.

⚙️ Configuration

Default Configuration

0xRay works out of the box with sensible defaults. The npm postinstall hook automatically sets up:

.opencode/
├── agents/         # 42 agent configurations (YAML configs)
├── skills/         # Framework skills
├── strray/
│   ├── codex.json      # Codex rules
│   ├── features.json   # Feature flags
│   └── config.json    # Token/memory management
└── hooks/          # Pre/post processing hooks

Customizing Agents

Edit .opencode/agents/ to customize agent behavior:

# Example: Customize enforcer agent
name: enforcer
maxComplexity: 40  # Only handle simple tasks
temperature: 0.2   # More precise responses
enabled: true

Feature Flags

Edit .opencode/strray/features.json to enable/disable features:

{
  "codexEnforcement": true,
  "agentGovernance": true,
  "analytics": true,
  "webhooks": true
}

Token Management

Edit .opencode/strray/config.json to adjust token limits:

{
  "token_management": {
    "maxPromptTokens": 20000,
    "warningThreshold": 15000
  }
}

See Configuration Reference for full options.

Version Pinning

0xRay supports pinning versions for reproducible installations:

{
  "version_pinning": {
    "strray_ai": "^1.22.0",
    "opencode": "^2.14.0",
    "skills": {
      "antigravity": "latest",
      "impeccable": "latest",
      "openviking": "latest",
      "claude_seo": "latest"
    }
  }
}

Add to .opencode/strray/features.json to pin specific versions.

📁 Project Structure

stringray/
├── src/
│   ├── __tests__/              # Test suites (unit, integration, performance)
│   ├── agents/                 # Agent implementations
│   ├── analytics/              # Pattern analysis & learning
│   ├── cli/                    # CLI commands
│   ├── circuit-breaker/        # Resilience patterns
│   ├── core/                   # Core framework
│   ├── delegation/             # Task routing & delegation
│   ├── enforcement/            # Codex enforcement
│   ├── infrastructure/         # IaC validation
│   ├── integrations/           # External integrations
│   │   ├── base/              # BaseIntegration framework
│   │   └── openclaw/          # OpenClaw integration
│   ├── mcps/                  # MCP server implementations
│   ├── monitoring/            # System monitoring
│   ├── orchestrator/          # Multi-agent orchestration
│   ├── performance/           # Performance optimization
│   ├── plugins/              # Plugin system
│   ├── postprocessor/         # Post-processing pipeline
│   ├── reporting/             # Report generation
│   ├── security/              # Security systems
│   ├── session/               # Session management
│   ├── test-utils/            # Test utilities and helpers
│   ├── validation/            # Agent config & estimation validators
│   └── jobs/                  # Background job management
├── .opencode/                 # OpenCode configuration
│   ├── agents/               # Agent configs (42 agents)
│   ├── strray/               # 0xRay config
│   │   ├── codex.json        # 60-term development codex
│   │   ├── features.json     # Feature flags
│   │   └── config.json       # Token management
│   └── hooks/                # Git hooks
├── skills/                    # 0xRay skills
├── docs/                      # Documentation
│   ├── reflections/          # Deep technical reflections
│   └── research/             # Research documents
└── scripts/                   # Build & utility scripts

💬 Usage

# System design
@architect design database schema for e-commerce

# Security audit
@security-auditor scan for vulnerabilities

# Code review
@code-reviewer review authentication module

# Testing
@testing-lead create tests for payment system

🔌 Framework Integration

0xRay integrates with your existing infrastructure via webhooks and APIs:

# CLI tool for integration
npx strray-integration --help
// Programmatic integration
import { StringRayIntegration } from 'strray-ai/integration';

const postProcessor = new PostProcessor(stateManager);
const integration = new StringRayIntegration(postProcessor);

// Express
app.use('/webhooks', integration.getWebhookApp());
app.use('/api/post-process', integration.getAPIApp());

// Fastify
fastify.register(integration.getWebhookRouter(), { prefix: '/webhooks' });
fastify.register(integration.getAPIRouter(), { prefix: '/api/post-process' });

Supported Webhooks:

  • GitHub (push, PR, issues)
  • GitLab (push, merge requests)
  • Bitbucket (push, pull requests)
  • Stripe (subscriptions, payments)

🎯 Skills

0xRay ships with 44 framework skills and provides a registry of 10 curated community sources with 170+ additional skills.

Skills Registry

Browse and install skills from verified GitHub repositories:

# Show starter packs and available sources
npx strray-ai skill:install

# Install a specific source
npx strray-ai skill:install agency-agents
npx strray-ai skill:install superpowers
npx strray-ai skill:install anthropic-skills

# Install from any GitHub repo (auto-detects format)
npx strray-ai skill:install https://github.com/user/skills-repo

# Manage the registry
npx strray-ai skill:registry list              # Show all sources
npx strray-ai skill:registry add --name X --url Y --desc "..." --license MIT
npx strray-ai skill:registry remove --name X

Starter Packs

PackSourcesSkillsBest For
Minimal Viable Powersuperpowers, anthropic-skills20+Solo devs, quick setup
Full Pro Setup+ agency-agents, impeccable, minimax200+Professional development
Agency/Team Mode+ gemini-skills, ai-web3-security220+Teams, security audits
Specialized+ vuejs-nuxt, ui-ux-pro-max230+Nuxt/Vue, UI/UX work

Registry Sources

SourceSkillsLicenseDescription
agency-agents170+MITAI agency agent definitions
superpowers14MITTDD, debugging, code review workflows
anthropic-skills10+MITOfficial Anthropic Claude Code skills
antigravity1300+MITCurated community skills
impeccable1Apache 2.0AI frontend design language
minimax20+MITFrontend, mobile, shader skills
gemini-skills10+Apache 2.0Official Google Gemini skills
ai-web3-security10+MITWeb3 security auditing
vuejs-nuxt5+MITVue.js 3, Nuxt 4+ skills
ui-ux-pro-max1MITProfessional UI/UX design

Impeccable - AI Frontend Design

Impeccable is a design language skill that teaches AI coding assistants professional frontend design:

/audit           # Find issues
/critique       # UX design review
/polish          # Pre-ship refinement
/typeset         # Fix typography
/arrange         # Fix layout & spacing

Framework Skills (30 Built-in)

0xRay includes 30 core skills for orchestration, compliance, architecture, and more — installed to .opencode/skills/ automatically.

License Information

All community skill sources are properly licensed. License files are in licenses/skills/:

SourceLicenseFile
agency-agentsMITlicenses/skills/LICENSE.agency-agents
superpowersMITlicenses/skills/LICENSE.superpowers
anthropic-skillsMITlicenses/skills/LICENSE.anthropic-skills
antigravityMITlicenses/skills/LICENSE.antigravity
impeccableApache 2.0licenses/skills/LICENSE.impeccable
minimaxMITlicenses/skills/LICENSE.minimax
gemini-skillsApache 2.0licenses/skills/LICENSE.gemini-skills
ai-web3-securityMITlicenses/skills/LICENSE.ai-web3-security
vuejs-nuxtMITlicenses/skills/LICENSE.vuejs-nuxt
ui-ux-pro-maxMITlicenses/skills/LICENSE.ui-ux-pro-max

🙏 Support & Star

If 0xRay helps you build better software, please consider:

📄 License

MIT License - see LICENSE for details.

Built with precision for enterprise-grade AI orchestration

Keywords

ai

FAQs

Package last updated on 19 May 2026

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts