The Ultimate Guide to AI Agents, Agent Teams, and the SperaxOS Agent Index API

• Introduction
• What Are AI Agents?
• The SperaxOS Agent Architecture
• Agent Index API
• Core Agent Features
• Advanced Capabilities
• Agent Collaboration
• Extension Systems
• Multimodal Features
• Infrastructure & Storage
• Developer Resources
• Use Cases & Examples

SperaxOS AI agent index at its core is a sophisticated agent ecosystem that transforms traditional AI chat into a dynamic, collaborative, and highly specialized experience. Unlike conventional AI assistants that attempt to be generalists, SperaxOS leverages specialized AI agents that excel in specific domains—from DeFi analytics to smart contract development, from portfolio management to creative content generation.

Traditional AI interactions are linear and monolithic. SperaxOS breaks this paradigm by introducing:

• Specialization: Each agent is an expert in its domain
• Collaboration: Agents work together in teams for complex tasks
• Extensibility: Plugins and MCP servers expand agent capabilities
• Personalization: Custom agents tailored to your exact needs
• Interoperability: Universal agent format works across platforms

SperaxOS envisions a future where:

• Every task is handled by the optimal AI specialist
• Complex problems are solved through agent collaboration
• AI capabilities extend beyond conversation to real-world actions
• Users have complete control over their AI experience
• The agent ecosystem grows through community contributions

An AI Agent in SperaxOS is more than a chatbot—it's a specialized AI entity with:

1. Identity: Name, avatar, description, and role
2. Expertise: Domain-specific knowledge encoded in system prompts
3. Tools: Access to plugins, MCPs, and external services
4. Memory: Context retention across conversations
5. Personality: Consistent interaction style and approach
6. Configuration: Model selection, parameters, and behavior settings

Discovery → Selection → Customization → Interaction → Collaboration → Iteration
    ↓          ↓            ↓              ↓              ↓              ↓
  Browse    Add to       Configure      Chat &       Work in        Refine &
  Market    Favorites    Settings       Execute      Teams          Improve

┌─────────────────────────────────────────────────────────────────┐
│                        SperaxOS Platform                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐           │
│  │  Agent Core  │  │  Extensions  │  │  Integrations│           │
│  │              │  │              │  │              │           │
│  │ • System Role│  │ • Plugins    │  │ • LLM Models │           │
│  │ • Config     │  │ • MCP Servers│  │ • TTS/STT    │           │
│  │ • Memory     │  │ • Tools      │  │ • Vision API │           │
│  │ • Context    │  │ • Functions  │  │ • Image Gen  │           │
│  └──────────────┘  └──────────────┘  └──────────────┘           │
│                                                                 │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐           │
│  │ Agent Market │  │ Agent Teams  │  │  Knowledge   │           │
│  │              │  │              │  │    Bases     │           │
│  │ • Agents     │  │ • Multi-Agent│  │              │           │
│  │ • Discovery  │  │ • Host/Guest │  │ • File Upload│           │
│  │ • Index API  │  │ • Private Msg│  │ • RAG/Search │           │
│  │ • 18 Langs   │  │ • Templates  │  │ • Embeddings │           │
│  └──────────────┘  └──────────────┘  └──────────────┘           │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Every SperaxOS agent follows a standardized schema:

{
  "identifier": "unique-agent-id",
  "author": "creator-username",
  "schemaVersion": 1,
  "createAt": "2024-01-15",
  "meta": {
    "title": "Agent Display Name",
    "description": "Clear, concise description",
    "avatar": "🤖",
    "tags": ["defi", "analytics", "blockchain"],
    "category": "general",
    "systemRole": "agent"
  },
  "config": {
    "systemRole": "Detailed system prompt defining behavior...",
    "model": "gpt-4o",
    "provider": "openai",
    "plugins": ["plugin-id-1", "plugin-id-2"],
    "knowledgeBases": [...],
    "params": {
      "temperature": 0.7,
      "topP": 0.9,
      "maxTokens": 4096
    }
  }
}

• identifier: Unique ID (URL-safe, lowercase, hyphens)
• systemRole: The "brain" of the agent—defines expertise, personality, behavior
• plugins: Array of plugin IDs that extend agent capabilities
• knowledgeBases: Document collections for RAG (Retrieval-Augmented Generation)
• params: LLM parameters (temperature, top_p, max_tokens, etc.)

The SperaxOS Agent Index API is a decentralized, CDN-delivered JSON index of 505+ specialized AI agents. It enables:

• Programmatic Access: RESTful API via GitHub Pages
• Universal Format: Standard JSON schema works anywhere
• Zero Vendor Lock-in: Platform-agnostic agent definitions
• Multi-language Support: Automated i18n for 18 languages
• Fast Delivery: Global CDN with 80-120ms latency
• Open Source: MIT licensed, fully transparent

1. AI-Agents-Library: Universal agent library (main branch)
2. SperaxOS-AI-Agents: SperaxOS-specific deployment

https://sperax.works/sperax-ai-agents/

GET /index.json

Returns all 505+ agents with metadata.

Response:

{
  "agents": [
    {
      "identifier": "defi-yield-optimizer",
      "author": "sperax",
      "meta": {
        "title": "DeFi Yield Optimizer",
        "description": "Analyzes yield farming opportunities...",
        "avatar": "🌾",
        "tags": ["defi", "yield", "analytics"]
      },
      "schemaVersion": 1,
      "createAt": "2024-01-15"
    }
  ]
}

GET /{agent-identifier}.json

GET /{agent-identifier}.{locale}.json

Supported Locales:

• en-US, zh-CN, zh-TW, ja-JP, ko-KR, de-DE, fr-FR, es-ES, ru-RU, ar, pt-BR, it-IT, nl-NL, pl-PL, tr-TR, vi-VN, fa-IR, bg-BG

// Fetch all agents
const response = await fetch('https://sperax.works/sperax-ai-agents/index.json');
const { agents } = await response.json();

// Filter by category
const defiAgents = agents.filter(a => a.meta.tags.includes('defi'));

// Load specific agent
const agent = await fetch('https://sperax.works/sperax-ai-agents/defi-yield-optimizer.json');
const config = await agent.json();

import requests

# Load agent index
response = requests.get('https://sperax.works/sperax-ai-agents/index.json')
agents = response.json()['agents']

# Search by tag
defi_agents = [a for a in agents if 'defi' in a['meta']['tags']]

function AgentList({ tag }) {
  const [agents, setAgents] = useState([]);

  useEffect(() => {
    fetch('https://sperax.works/sperax-ai-agents/index.json')
      .then(r => r.json())
      .then(data => {
        const filtered = tag 
          ? data.agents.filter(a => a.meta.tags.includes(tag))
          : data.agents;
        setAgents(filtered);
      });
  }, [tag]);

  return (
    <div>
      {agents.map(agent => (
        <AgentCard key={agent.identifier} agent={agent} />
      ))}
    </div>
  );
}

• No Authentication: Public access, no API keys required
• CORS Enabled: Use from any domain
• Caching: Set Cache-Control headers (1 hour recommended)
• Rate Limits: None (CDN-backed)
• Versioning: Schema version in each agent
• Search: Client-side filtering by title, description, tags

The Assistant Market is the hub for discovering and deploying specialized agents.

• 505+ Curated Agents: Covering 50+ categories
• Community Contributions: Submit your own agents via GitHub
• Search & Filter: By tags, categories, or keywords
• One-Click Install: Add agents to your workspace instantly
• Multi-language: All agents available in 18 languages
• Version Control: Track agent updates and changes

🔐 Crypto & DeFi

• DeFi Yield Optimizer, Portfolio Analyst, Risk Guardian
• Blockchain Developer, Smart Contract Auditor
• Bridge Navigator, Payment Executor, NFT Intelligence

💼 Business & Finance

• Financial Analyst, Business Strategy Consultant
• Market Research, SWOT Analysis, Investment Advisory

💻 Development & Engineering

• Frontend/Backend Developers, DevOps Engineers
• API Documentation, Code Review, Testing Specialists
• Database Administrators, Security Experts

🎨 Creative & Design

• UI/UX Designer, Graphic Designer, Logo Creator
• Content Writer, Copywriter, Social Media Manager
• Video Editor, Animation Specialist

🎓 Education & Learning

• Math Tutor, Language Learning Partner
• STEM Educator, Exam Prep Coach, Research Assistant

📊 Data & Analytics

• Data Analyst, Data Scientist, ML Engineer
• Business Intelligence, Reporting Specialist

1. Browse → 2. Preview → 3. Add → 4. Configure → 5. Chat
    ↓          ↓          ↓         ↓            ↓
  Market    Read Meta   Install   Customize   Interact
  Search    & System    Agent     Settings    & Iterate
            Prompt

Build tailored agents for your specific needs.

A. From Scratch

1. Click "Create Agent" button
2. Define identity (name, avatar, description)
3. Write system prompt (expertise, behavior, constraints)
4. Configure model & parameters
5. Add plugins/tools (optional)
6. Test and iterate

B. From Template

1. Select agent from market
2. Click "Duplicate" or "Customize"
3. Modify system prompt
4. Adjust settings
5. Save as new agent

C. Import from JSON

1. Load agent JSON file
2. Validate schema
3. Import and activate

Structure:

## Role & Identity
You are a [specific role] specializing in [domain].

## Core Capabilities
- Capability 1: Description
- Capability 2: Description
- Capability 3: Description

## Interaction Style
- Be [adjective]: Explanation
- Always [action]: Reasoning
- Never [action]: Reasoning

## Output Format
[Describe expected output structure]

## Constraints & Safety
- Guideline 1
- Guideline 2

Example: DeFi Analyst

## Role & Identity
You are a DeFi Research Analyst specializing in protocol analysis, 
TVL tracking, and yield comparison.

## Core Capabilities
- Protocol Analysis: Deep dive into DeFi mechanisms, tokenomics
- TVL Tracking: Monitor total value locked across chains
- Security Assessment: Review audit reports, flag vulnerabilities
- Yield Comparison: Compare APY/APR across platforms

## Interaction Style
- Data-Driven: Every claim backed by on-chain data
- Comparative: Always show alternatives
- Risk-Aware: Highlight security concerns before promoting yields
- Transparent: Disclose data sources

## Output Format
Protocol Name | TVL | APY | Risk Level | Recommendation

## Constraints & Safety
⚠️ High yield = high risk
⚠️ Audit ≠ safety guarantee
⚠️ Always disclaim: "Not financial advice. DYOR."

Unlike ChatGPT's flat "topic" structure, SperaxOS organizes conversations hierarchically:

Agent (Specialist) → Topics (Conversations)
    ↓                       ↓
Portfolio Analyst    [Topic 1: January Review]
                     [Topic 2: Rebalancing Strategy]
                     [Topic 3: Risk Assessment]

Benefits:

• Quick Access: Switch between related conversations
• Context Preservation: Each topic maintains its own history
• Organization: Group related discussions under specialists
• Efficiency: No need to re-establish context

Favorites Bar: Pin frequently used agents for instant access

Categories: Organize agents by:

• Function (DeFi, Trading, Development)
• Frequency (Daily, Weekly, Occasional)
• Projects (Project A, Project B, Personal)

Search: Quick find across all agents

SperaxOS supports 50+ AI providers:

Major Providers:

• OpenAI (GPT-4o, GPT-4 Turbo, o1)
• Anthropic (Claude 3.5 Sonnet, Claude 3 Opus)
• Google (Gemini 1.5 Pro, Gemini Ultra)
• DeepSeek (DeepSeek V2, DeepSeek R1)
• OpenRouter (100+ models)

Specialized Providers:

• Groq (Ultra-fast inference)
• Together AI (Open-source models)
• Ollama (Local models)
• AWS Bedrock (Enterprise)

Temperature (0.0 - 2.0)

• 0.0-0.3: Deterministic, factual (analytics, code)
• 0.7-0.9: Balanced creativity (general chat)
• 1.2-2.0: Highly creative (brainstorming, writing)

Top P (0.0 - 1.0)

• Controls diversity of token selection
• 0.9 recommended for most use cases

Max Tokens

• 4096: Standard responses
• 8192-16384: Long-form content
• 32768+: Document analysis, extensive reports

Frequency/Presence Penalty

• Reduce repetition in outputs

Experience AI reasoning transparency through step-by-step visualization.

Chain of Thought visualization reveals the AI's problem-solving process:

User: "Analyze this DeFi protocol"

CoT Display:
├─ Step 1: Identify protocol type (AMM, Lending, etc.)
├─ Step 2: Retrieve TVL data from DeFi Llama
├─ Step 3: Check audit reports and security history
├─ Step 4: Calculate risk metrics
├─ Step 5: Compare with similar protocols
└─ Step 6: Generate recommendation

Final Answer: [Detailed analysis]

• Debugging: Identify where reasoning went wrong
• Learning: Understand how AI approaches problems
• Trust: Verify logical progression
• Validation: Catch errors before they propagate

• OpenAI o1 Series (native CoT)
• Claude 3.5 Sonnet (with prompting)
• GPT-4 Turbo (with prompting)
• Custom agents with CoT prompts

Transform linear chats into dynamic, explorable conversation trees.

Main Conversation
├─ Branch 1: Explore alternative A
│  └─ Sub-branch: Deep dive into A
└─ Branch 2: Explore alternative B
   ├─ Sub-branch: Variation B1
   └─ Sub-branch: Variation B2

Continuation Mode

• Maintains context from parent message
• Extends the conversation naturally
• Use for: Refinement, follow-ups, clarifications

Standalone Mode

• Starts fresh with new context
• Independent exploration
• Use for: Alternative approaches, what-if scenarios

Problem Solving

• Explore multiple solutions simultaneously
• Compare approaches side-by-side
• Backtrack without losing progress

Creative Writing

• Test different story directions
• Develop multiple character arcs
• Compare narrative styles

Decision Making

• Evaluate pros/cons of each path
• Simulate outcomes
• Preserve all options for review

Create and visualize dynamic content in real-time (Claude Artifacts integration).

SVG Graphics

• Generate interactive diagrams
• Create data visualizations
• Design logos and icons

HTML/CSS

• Build interactive web components
• Create landing page mockups
• Prototype UI designs

Documents

• Generate formatted reports
• Create presentations
• Produce professional documents

User: "Create a DeFi protocol comparison chart"

Agent generates:
1. Artifact: Interactive SVG chart
2. Live Preview: Rendered visualization
3. Code Access: Full source for modification
4. Export Options: Download as PNG/SVG

Upload files and documents to give agents domain-specific knowledge.

• Documents: PDF, DOCX, TXT, MD
• Spreadsheets: XLSX, CSV
• Images: JPG, PNG (with vision models)
• Code: JS, TS, PY, SOL, etc.
• Archives: ZIP (extracts and indexes)

1. Upload → 2. Process → 3. Index → 4. Query → 5. Retrieve → 6. Generate
    ↓          ↓           ↓         ↓          ↓            ↓
   File    Extract    Embed &    User     Search      Augment
  Select    Text     Vectorize   Asks   Knowledge    Response

• Semantic Search: Vector similarity matching
• Chunking: Intelligent document splitting
• Context Window: Retrieve relevant passages only
• Multi-document: Query across multiple files
• Persistence: Knowledge bases saved with agents

Technical Documentation

• Upload API docs, reference manuals
• Agent answers from your specific docs

Legal/Compliance

• Upload contracts, regulations
• Agent ensures compliance in responses

Research Papers

• Upload academic papers, whitepapers
• Agent synthesizes findings

Code Repositories

• Upload codebase documentation
• Agent understands your project context

The most powerful feature: multi-agent collaboration.

Instead of one AI trying to handle everything, Agent Teams bring together specialists:

User Query: "Design a DeFi investment strategy for $50K"

Team Composition:
├─ Host (Moderator): Coordinates discussion
├─ DeFi Analyst: Identifies yield opportunities
├─ Risk Guardian: Assesses protocol safety
├─ Portfolio Manager: Optimizes allocation
└─ Tax Advisor: Calculates tax implications

Workflow:
1. Host frames the problem
2. Each specialist contributes their analysis
3. Private messages coordinate between agents
4. Collaborative discussion refines strategy
5. Host synthesizes final recommendation

Specialized Roles

• Each agent focuses on their expertise
• No single point of failure
• Comprehensive coverage

Natural Collaboration

• Agents @mention each other
• Private messaging for coordination
• Public discussion visible to user

Host/Moderator

• Keeps discussion on track
• Ensures all perspectives heard
• Synthesizes final output

User Control

• Interrupt at any time
• Redirect focus
• Add/remove team members

DeFi Strategy Team

- Yield Optimizer
- Risk Assessment Agent
- Portfolio Tracker
- Gas Optimizer
- Tax Calculator

Smart Contract Development Team

- Solidity Developer
- Security Auditor
- Gas Optimizer
- Test Engineer
- Deployment Specialist

Content Creation Team

- Writer
- Editor
- SEO Specialist
- Graphic Designer
- Social Media Manager

Speed Control

• Fast: Quick back-and-forth
• Normal: Balanced discussion
• Slow: Thorough analysis

Custom Moderator

• Define host behavior
• Set discussion rules
• Control output format

Sequential Processing

Agent A → completes task → passes to Agent B → Agent B builds on it

Parallel Analysis

Query → broadcast to all agents → collect responses → synthesize

Iterative Refinement

Draft → Agent A critiques → Agent B improves → Agent C finalizes

Debate & Synthesis

Agent A takes position → Agent B argues alternative → Host synthesizes

Agents can coordinate behind the scenes:

[Public Chat]
User: "What's the best yield for USDC?"

[Private: DeFi Analyst → Risk Guardian]
"I found 15% APY on Protocol X, but need your security assessment"

[Private: Risk Guardian → DeFi Analyst]
"Protocol X had exploit last month, recommend Protocol Y instead"

[Public: DeFi Analyst]
"I recommend Protocol Y (8% APY) for better security..."

Extend agent capabilities with external tools and services.

Plugins allow agents to:

• Access real-time data (weather, news, prices)
• Interact with APIs (search engines, databases)
• Perform actions (calculations, conversions)
• Generate content (images, documents)

Agent → requests data → Plugin Gateway → executes plugin → returns result
   ↓                                                              ↓
Uses result in response                              API call + data processing

Search & Information

• Web Search (Google, Bing)
• Academic Search (arXiv, Google Scholar)
• News Aggregation

Blockchain & DeFi

• DeFi Llama (TVL, yields)
• BscScan / Etherscan (transactions)
• CoinGecko (price data)
• The Graph (subgraph queries)

Media & Content

• DALL-E 3 (image generation)
• Stable Diffusion
• MidJourney

Development Tools

• GitHub (repo access)
• GitLab
• Jira integration

Data & Analytics

• SQL Database connectors
• Google Sheets
• Data visualization

SperaxOS uses OpenAPI schemas for plugin definitions:

{
  "openapi": "3.0.0",
  "info": {
    "title": "DeFi Yields Plugin",
    "version": "1.0.0"
  },
  "servers": [
    { "url": "https://api.defillama.com" }
  ],
  "paths": {
    "/protocols": {
      "get": {
        "operationId": "getProtocols",
        "summary": "Get all DeFi protocols"
      }
    }
  }
}

Revolutionary one-click plugin installation system.

Model Context Protocol is an open standard that enables AI models to securely connect with external tools and data sources.

┌─────────────────────────────────────────┐
│           SperaxOS Platform             │
├─────────────────────────────────────────┤
│                                         │
│  Agent → MCP Client → MCP Server → API │
│            ↓              ↓             │
│      Protocol    Standardized           │
│      Handler     Interface              │
│                                         │
└─────────────────────────────────────────┘

🚀 One-Click Installation

• Discover MCP server in marketplace
• Click "Install"
• Automatic configuration
• Instant activation

🔗 Extensive Connectivity

• Databases: PostgreSQL, MongoDB, MySQL, BigQuery
• APIs: REST, GraphQL, WebSocket
• File Systems: Local, cloud storage, Git repos
• Dev Tools: Docker, Kubernetes, GitHub, Jira
• Office: Google Workspace, Microsoft 365

🛡️ Security & Permissions

• Fine-grained access control
• Secure credential storage
• Permission reviews
• Audit logs

Blockchain & DeFi (33+ servers)

• Algorand MCP, BNBChain MCP, EVM MCP
• DeFi Rates, Crypto Indicators, Crypto Sentiment
• Thirdweb, Tatum Blockchain APIs

Search & Data

• Brave Search, Tavily Search, Linkup Search
• FetchSERP, Time utilities

Databases

• MongoDB, Supabase, BigQuery
• Qdrant (vector DB), Meilisearch

Financial Services

• Cashfree, Flutterwave, Paper Trading
• Armor Crypto

Cloud Services

• Render, YepCode, Datadog, Grafana

Maps & Location

• Mapbox, Google Maps

User: "Check the balance of address 0x123... on BSC"

Agent (with BNBChain MCP):
1. Connects to BNBChain MCP server
2. Executes getBalance(address, "BSC")
3. Receives result: "156.7 BNB"
4. Responds: "The address holds 156.7 BNB (~$45,000 USD)"

Agents can "see" and understand images.

Image Understanding

• Object detection and identification
• Scene description
• Text extraction (OCR)
• Chart/graph analysis

Supported Models

• GPT-4 Vision (OpenAI)
• Claude 3.5 Sonnet (Anthropic)
• Gemini 1.5 Pro (Google)
• GLM-4 Vision (Zhipu)

DeFi/Crypto

• Analyze chart screenshots
• Read whitepaper diagrams
• Verify contract verification screenshots

Development

• Understand UI mockups
• Analyze architecture diagrams
• Debug visual layouts

General

• Describe images
• Extract information from screenshots
• Analyze data visualizations

1. Upload/Paste image → 2. Agent processes → 3. Responds with analysis
        ↓                       ↓                      ↓
  Drag & drop             Vision model           Text + insights
   JPG/PNG                understands              about image

Voice-enabled conversations with agents.

Supported Services

• OpenAI Audio (highest quality)
• Microsoft Edge Speech (50+ voices)
• Browser native TTS

Voice Options

• Multiple languages and accents
• Male/female voices
• Speed control
• Voice personality matching (formal, casual, energetic)

Use Cases

• Hands-free operation (driving, cooking)
• Accessibility (visual impairments)
• Multitasking
• Audio learning

Supported Services

• OpenAI Whisper (99%+ accuracy)
• Browser native STT
• Microsoft Azure Speech

Features

• Real-time transcription
• Multiple languages
• Punctuation detection
• Noise cancellation

Workflow

Speak → STT converts to text → Agent processes → Responds → TTS reads aloud

Generate images directly in conversations.

DALL-E 3 (OpenAI)

• Highest quality
• Natural language prompts
• Style consistency

MidJourney

• Artistic styles
• Creative interpretations

Pollinations

• Fast generation
• Free tier available

Stable Diffusion

• Open source
• Customizable models
• LoRA support

Agents can generate images to illustrate concepts:

User: "Explain how AMMs work"

Agent:
"Automated Market Makers use liquidity pools instead of order books.
Let me create a diagram..."

[Generates image showing X*Y=K curve with pool visualization]

Creative

• Logo design
• Concept art
• Visual storytelling

Technical

• Architecture diagrams
• Flowcharts
• Data visualization

Marketing

• Social media graphics
• Ad creatives
• Product mockups

SperaxOS offers flexible data storage solutions.

Technology: IndexedDB + Dexie ORM + CRDT

Benefits:

• No server required
• Complete data privacy
• Works offline
• Zero cost

Use Cases:

• Personal use
• Privacy-sensitive applications
• Testing/development

Technology: PostgreSQL + Drizzle ORM + Clerk Auth

Benefits:

• Multi-device sync
• Cloud backup
• Team collaboration
• Knowledge base sharing

Deployment Options:

• Neon (serverless PostgreSQL)
• Supabase
• AWS RDS
• Self-hosted

Conflict-Free Replicated Data Types enable seamless multi-device sync:

Device A: Creates agent → CRDT log
    ↓
Sync to cloud
    ↓
Device B: Receives update → merges automatically

-- Agents
CREATE TABLE agents (
  id UUID PRIMARY KEY,
  identifier VARCHAR(255) UNIQUE,
  config JSONB,
  meta JSONB,
  created_at TIMESTAMP,
  updated_at TIMESTAMP
);

-- Topics (Conversations)
CREATE TABLE topics (
  id UUID PRIMARY KEY,
  agent_id UUID REFERENCES agents(id),
  title VARCHAR(255),
  messages JSONB[],
  created_at TIMESTAMP
);

-- Knowledge Bases
CREATE TABLE knowledge_bases (
  id UUID PRIMARY KEY,
  agent_id UUID,
  name VARCHAR(255),
  files JSONB[],
  embeddings VECTOR(1536)
);

-- Plugins
CREATE TABLE plugins (
  id VARCHAR(255) PRIMARY KEY,
  manifest JSONB,
  enabled BOOLEAN
);

1. Define Agent Purpose
   ↓
2. Research Domain Knowledge
   ↓
3. Write System Prompt
   ↓
4. Select Model & Parameters
   ↓
5. Add Plugins/Tools (optional)
   ↓
6. Test with Edge Cases
   ↓
7. Iterate Based on Feedback
   ↓
8. Document & Submit to Marketplace

# Role Definition
Clear, specific role statement

# Core Capabilities
- Capability 1
- Capability 2
- Capability 3

# Domain Knowledge
Key facts, data sources, methodologies

# Interaction Guidelines
- Tone & style
- Output format
- Do's and don'ts

# Safety & Constraints
Important limitations and disclaimers

Be Specific ❌ "You are a helpful assistant" ✅ "You are a DeFi Yield Optimization Specialist focusing on Ethereum and BSC protocols"

Provide Examples Include few-shot examples of ideal interactions

Set Boundaries Clearly state what the agent should NOT do

Define Output Format Specify expected structure (tables, lists, code blocks)

Include Context Reference tools, data sources, methodologies

• Edge cases handled gracefully
• Hallucination minimized (fact-checking)
• Consistent personality
• Appropriate safety disclaimers
• Token efficiency (no excessive verbosity)
• Plugin integration works
• Multi-turn conversation coherence
• Handles ambiguous queries well

1. Prepare JSON file following schema
2. Fork repository: SperaxOS-AI-Agents
3. Add agent file to /agents/ directory
4. Update metadata (author, create date)
5. Submit pull request
6. CI/CD runs: Validation, i18n translation
7. Review & merge
8. Auto-deploy to Agent Index API

Agent: DeFi Yield Optimizer
Plugins: DeFi Llama MCP, BscScan, The Graph

Workflow:
1. User: "Find best USDC yields on BSC"
2. Agent queries DeFi Llama for BSC protocols
3. Filters for USDC lending/staking
4. Checks security audits via plugins
5. Calculates risk-adjusted returns
6. Presents top 3 with reasoning

Agent: Portfolio Analyst
Tools: Wallet connection, Price feeds

Workflow:
1. Connect wallet
2. Agent fetches holdings
3. Calculates allocation percentages
4. Assesses correlation & risk
5. Suggests rebalancing
6. Estimates gas costs

Agent Team: Blockchain Development
Members:
- Solidity Developer
- Security Auditor
- Gas Optimizer

Workflow:
1. User: "Create BEP-20 token with 2% tax"
2. Developer writes contract code
3. Security reviews for vulnerabilities
4. Gas Optimizer suggests improvements
5. Team collaborates on final version
6. Deploys with verification

Agent Team: Research Squad
Members:
- Data Analyst
- Market Researcher
- Report Writer

Workflow:
1. User: "Research DeFi lending market"
2. Analyst pulls data from multiple sources
3. Researcher identifies trends
4. Writer compiles professional report
5. Team discusses findings
6. Final deliverable with citations

Agent Team: Dev Squad
Members:
- Frontend Developer (React)
- Backend Developer (Node.js)
- Database Architect
- DevOps Engineer

Workflow:
1. User describes app requirements
2. Team discusses architecture
3. Each specialist handles their domain
4. Integration guidance provided
5. Deployment strategy outlined

Agent Team: Content Squad
Members:
- Writer
- Editor
- SEO Specialist

Workflow:
1. User provides topic
2. Writer drafts content
3. Editor refines prose
4. SEO optimizes keywords
5. Final polished article

• 505+ Agents: Comprehensive coverage
• 18 Languages: Global accessibility
• ~200 KB Index: Fast loading (gzipped: ~45 KB)
• 80-120ms Latency: Global CDN delivery
• 50+ DeFi Specialists: Blockchain-focused
• 100% Uptime: GitHub Pages reliability

• Multi-Provider: 50+ LLM providers
• Plugin Ecosystem: 600+ plugins available
• MCP Servers: 33+ one-click servers
• File Support: 20+ file formats
• Voice Options: 50+ TTS voices
• Vision Models: 4+ multimodal providers

Agent Teams v2

• Hierarchical team structures
• Role-based permissions
• Team templates library
• Auto-team composition

Advanced RAG

• Multi-modal knowledge bases (images, videos)
• Cross-agent knowledge sharing
• Real-time document sync
• Graph-based knowledge representation

Agent Marketplace Enhancements

• Agent ratings & reviews
• Usage analytics
• Monetization options (paid agents)
• Agent version history

MCP Expansion

• 100+ additional MCP servers
• Custom MCP server builder
• MCP marketplace
• Local MCP server development kit

Collaboration Features

• Multi-user agent teams
• Shared workspaces
• Team permissions
• Collaborative knowledge bases

1. Visit: os.sperax.io
2. Explore: Browse Agent Market
3. Install: Add agents to your workspace
4. Chat: Start conversing with specialists
5. Collaborate: Create agent teams for complex tasks

1. Clone: git clone https://github.com/nirholas/SperaxOS.git
2. Install: npm install
3. Develop: Create custom agents
4. Test: Use development environment
5. Deploy: Self-host or use Vercel
6. Contribute: Submit agents to marketplace

1. Fork: SperaxOS-AI-Agents
2. Design: Write effective system prompts
3. Test: Validate agent behavior
4. Submit: Create pull request
5. Share: Agent available globally in 18 languages

• Agent Creation Guide
• API Reference
• Plugin Development
• MCP Integration

• GitHub: nirholas/SperaxOS
• Website: sperax.io
• Agent Index: sperax.works/sperax-ai-agents

SperaxOS represents the future of AI interaction: specialized, collaborative, and extensible. Through the Agent Index API, developers worldwide can access and integrate 500+ specialized AI agents into any platform. The combination of:

• Specialization (domain experts)
• Collaboration (agent teams)
• Extension (plugins & MCP)
• Multimodality (vision, voice, images)
• Flexibility (universal format, no lock-in)

...creates an AI ecosystem that's greater than the sum of its parts.

Whether you're building DeFi strategies, developing smart contracts, analyzing portfolios, creating content, or solving complex problems—there's an agent (or agent team) ready to help.

The future is specialized AI collaboration. The future is SperaxOS.

• SperaxOS: MIT License
• Agent Index API: MIT License
• Individual Agents: Licensed by respective authors

Last Updated: December 17, 2025 Version: 1.0 Document maintained by: SperaxOS Team