JARVIS

A Persistent, Personal Context Engine

A mesh of intelligent layers working together to run, optimize, and upgrade your life.
Starting with crypto. Building toward everything.

---

Table of Contents

• What Jarvis Is
• Why Crypto First (But Not Crypto Only)
• The Architecture: A Mesh of Smart Agents
• Mission Control + OpenClaw Expansion Blueprint
• Economic Model: Open Source First
• What Jarvis Does Today
• Core Capabilities
• Quick Start
• Documentation & Legacy Docs
• Repository Map
• The Portable Brain
• Trading Engine
• Staking System
• Credit System
• Bags.fm Integration
• Treasury Management
• Self-Evolution System
• Intelligent Model Routing
• Conversation Engine
• Cross-App Logic Loop
• Voice Control
• Cross-Platform Support
• Dashboard & Data Engine
• Telegram Bot
• Standalone Wallet
• Current Integrations
• Future Platforms
• API Reference
• Architecture Deep Dive
• MCP & Semantic Memory
• Configuration
• Deployment
• Recent Updates
• Change History & Traceability
• Roadmap
• Community
• FAQ
• Contributing
• Security
• License

---

🌐 What Jarvis Is

Jarvis is not a product in the traditional sense. It is not just an app, a bot, a trading system, or an AI assistant.

Jarvis is a persistent, personal context engine—a mesh of intelligent layers and smart agents that work together to quietly run, optimize, and upgrade your life in the background.

The Vision

The inspiration is simple and familiar: the Iron Man version of Jarvis—the system that quietly upgrades your life without demanding your attention. Something that knows you across all of your devices. Something that understands your preferences, habits, goals, frustrations, and patterns—without you needing to constantly configure it, prompt it, or manage it.

Today's AI tools exist in isolation.

• Each one has its own interface
• Its own workflows
• Its own learning curve

You are expected to orchestrate them.

Jarvis flips that model entirely.

Instead of you adapting to software, the software adapts to you.

Context Is the Product

Jarvis tracks context across your life.

Not just commands. Not just prompts. Not just conversations.

Context includes:

• Your preferences
• Your routines
• Your constraints
• Your financial posture
• Your goals
• Your risk tolerance
• Your attention patterns
• Your digital footprint
• Your environment over time

By unifying this context, Jarvis becomes a single operational layer that sits quietly beneath everything else.

You don't need to be a power user. You don't need to understand AI workflows. You don't need to be technical. You don't need to understand crypto.

Jarvis exists so you don't have to manage complexity at all.

From Assistance to Autonomy

In the beginning, Jarvis assists.

• It observes
• It suggests
• It explains
• It optimizes

Over time, Jarvis earns autonomy.

Nowhere is this clearer than in trading.

Jarvis is designed to evolve into a fully autonomous trading engine—one that:

• Operates on-chain
• Executes transparently
• Learns from outcomes
• Compounds both capital and intelligence
• Improves itself continuously
• Works while you sleep

Trading is the first domain where Jarvis becomes truly autonomous because it is measurable, auditable, and objective.

From there, autonomy expands outward—into scheduling, optimization, installations, coordination, and eventually the broader mechanics of daily life.

The End Goal

Jarvis is not trying to replace humans.

It is trying to remove friction.

It is a persistent, personal context engine that quietly unifies intelligence, automation, finance, and daily life into a single system—one that works in the background, upgrades itself, and upgrades you along the way.

---

🚀 Why Crypto First (But Not Crypto Only)

Jarvis started in crypto intentionally.

Not because it was meant to be only a crypto product—but because crypto is the one environment where the future already exists.

The Proving Ground

In its first phase, Jarvis lives natively on Solana. This is not an accident or a branding choice. Solana provides something no other ecosystem currently can: a fully on-chain, real-time, high-frequency environment where data, assets, execution, analytics, and automation are all transparent, composable, and verifiable by design.

Crypto offers:

• Real-time markets
• On-chain execution
• Transparent outcomes
• Autonomous capital movement
• Programmable incentives
• Global, permissionless access

These properties make crypto the ideal proving ground for autonomy.

Jarvis launches with a strong trading and analytics context not because trading is the end goal—but because it is the hardest place to build something real. Markets are unforgiving. They provide immediate feedback. They expose bad logic quickly. And they reward systems that can learn, adapt, and execute correctly under pressure.

Crypto Is the Training Ground, Not the Identity

In this sense, crypto is not Jarvis's identity. It is Jarvis's training ground.

If a system can survive markets, it can survive anything.

Once Jarvis proves itself in trading—operating autonomously, generating value, and continuously improving—it expands outward into:

• Productivity
• Communication
• Devices
• Health
• Smart homes
• Vehicles
• Robots

The architecture is designed for this from day one.

---

🧩 The Architecture: A Mesh of Smart Agents

Jarvis is not one monolithic intelligence.

It is a mesh of smart agents and intelligent layers, each responsible for observing, understanding, and improving different parts of your digital and real-world environment.

The Core Layers

Context → Intelligence → Action → Feedback → Memory

Everything in Jarvis fits into one of these layers:

The Agents

These agents:

• Share context
• Coordinate through a unified memory
• Learn from outcomes
• Compress and refine knowledge over time
• Operate locally and securely
• Remain optional and non-blocking

If an AI agent goes offline, Jarvis continues to function normally. Intelligence is additive, not required. Trust is earned, not assumed.

This mesh architecture allows Jarvis to scale horizontally across:

• Devices
• Applications
• Environments
• Domains
• Physical systems (future)

Autonomy Is Gated

Jarvis doesn't start with full autonomy. It earns trust through success:

• Successful actions without errors
• Accurate predictions
• User satisfaction feedback
• Time-weighted reputation building

Every autonomous action is:

• Auditable
• Reversible
• Transparent
• Gated by permission levels

You remain in control. Always.

Mission Control + OpenClaw Expansion Blueprint

Jarvis is now explicitly split into two cooperating planes:

• OpenClaw harness for execution, autonomy, and user-facing actions
• Mission Control for governance, evaluation, versioning, and promotion

This split keeps systems fast and expressive without uncontrolled drift.

Why this matters

• Avoids "per-agent prompt hacking" across the fleet
• Preserves personality and autonomy while keeping behavior measurable
• Supports both individual users and enterprise teams from one architecture

Product lanes

• Personal lane: private, local-first, fast setup, focused on life/work automation
• Enterprise lane: role-aware teams, domain packs (HR, legal, infra, engineering), audit-ready operations

Core boundary

Source of truth

The complete staged roadmap, boundaries, and scaling model are documented in:

• docs/architecture/MISSION_CONTROL_OPENCLAW_EXPANSION.md

---

💎 Economic Model: Open Source First

Jarvis is built on first principles.

It is:

• Free
• Open-source
• Self-upgrading
• Always migrating toward smaller, faster, more powerful models

It runs on a new local node architecture powered by LLaMA-based models and free access to advanced intelligence through Claude-compatible runtimes. This makes Jarvis viable at ultra-low cost, without subscriptions, without data extraction, and without centralized control.

Your data stays local. Your context stays yours. Your intelligence compounds over time.

Revenue Distribution

The economic model is intentionally simple and aligned:

This structure ensures that:

• Users benefit directly from adoption
• Incentives remain aligned long-term
• Value creation is shared, not hoarded
• The system can sustain itself without rent-seeking

The Linux of AI Context

Jarvis is built with the same ethos as Linux:

• Open
• Composable
• Community-owned
• Endlessly adaptable

We are building the Linux of AI context models—something that levels the playing field, making advanced AI accessible to the "little guy," not just engineers or specialists.

---

⚡ What Jarvis Does Today

While the vision is expansive, Jarvis is already operational and generating value in several domains:

1. Autonomous Crypto Trading

• 81+ trading strategies running 24/7 on Solana
• Live treasury management via Jupiter DEX
• Sophisticated risk management: Position sizing, stop losses, circuit breakers
• Real-time sentiment analysis via Grok AI
• Transparent, on-chain execution

2. Multi-Platform Intelligence

• Twitter/X Bot (@Jarvis_lifeos): Autonomous posting, engagement, trend analysis
• Telegram Bot (@Jarviskr8tivbot): Full admin interface, trading controls, real-time alerts
• Web Dashboard: Portfolio management, analytics, strategy monitoring
• Voice Control: Desktop app integration (macOS/Windows/Linux)
• API: RESTful API for third-party integrations

3. Self-Improving Core

• Semantic memory system: 100+ learnings indexed with BGE embeddings
• 18 Model Context Protocols (MCPs): ast-grep, nia, firecrawl, postgres, perplexity, and more
• Cross-session learning: No knowledge loss between sessions
• Trust ladder system: Earns autonomy through successful actions
• Reflection cycles: Nightly self-assessment and improvement

4. Bags.fm Integration

• Real-time monitoring of token graduations
• Investment analysis with Grok AI scoring
• Multi-dimensional evaluation: Bonding curve, creator, social, market, distribution
• Automated intel reports via Telegram

5. Treasury & Staking

• Max 50 concurrent positions
• Risk-tiered position sizing (ESTABLISHED, MID, MICRO, SHITCOIN)
• Active stop loss monitoring (checks every 60 seconds)
• $KR8TIV staking: Earn SOL from trading profits

---

🎯 Core Capabilities

Autonomous Intelligence

Orchestrator: Central controller coordinating all modules with content recommendations, smart reply decisions, and background learning tasks.

Trading Intelligence

Data & Analytics

Security & Resilience

---

🚀 Quick Start

Prerequisites

• Python 3.11+
• Solana CLI (for trading features)
• PostgreSQL (for semantic memory)
• Node.js 18+ (for frontend)

Installation

# Clone the repository
git clone https://github.com/Matt-Aurora-Ventures/Jarvis.git
cd Jarvis

# Install Python dependencies
pip install -r requirements.txt

# Set up environment variables
cp .env.example .env
# Edit .env with your API keys

# Initialize the database
python scripts/init_db.py

# Run the supervisor (starts all components)
python bots/supervisor.py

Configuration

Key environment variables:

# Solana
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
TREASURY_LIVE_MODE=true  # Set to false for dry-run testing

# APIs
XAI_API_KEY=your_grok_api_key
TELEGRAM_BOT_TOKEN=your_telegram_token
TWITTER_BEARER_TOKEN=your_twitter_bearer_token
HELIUS_API_KEY=your_helius_api_key
BITQUERY_API_KEY=your_bitquery_api_key

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/jarvis

# Trading
MAX_POSITIONS=50
LOW_BALANCE_THRESHOLD=0.01
LIFEOS_KILL_SWITCH=false  # Emergency trade halt

Running Components Individually

# Trading bot only
python bots/treasury/trading.py

# Telegram bot only
python tg_bot/bot.py

# Twitter/X bot only
python bots/twitter/autonomous_engine.py

# Sentiment reporter only
python bots/buy_tracker/sentiment_report.py

# Bags Intel monitor only
python bots/bags_intel/bags_intel_bot.py

---

📚 Documentation & Legacy Docs

Jarvis uses this root README as the canonical source of truth for product narrative, architecture overview, and deployment guidance.

• Canonical README: README.md
• GitBook documentation: docs/gitbook
• Legacy README snapshots (archived for historical context): docs/history

If you encounter older links referencing README_NEW.md or README_BACKUP.md, use the archived copies and defer to this README for current guidance.

---

📂 Repository Map

jarvis/
├── bots/
│   ├── supervisor.py              # Main orchestrator
│   ├── treasury/                  # Trading engine (Jupiter DEX)
│   ├── twitter/                   # X/Twitter bot (autonomous posting)
│   ├── buy_tracker/               # KR8TIV token tracking + sentiment
│   ├── bags_intel/                # Bags.fm graduation monitoring
│   ├── clawdmatt/                 # ClawdBot: Research & analysis agent
│   ├── clawdjarvis/               # ClawdBot: Coordination & execution agent
│   ├── clawdfriday/               # ClawdBot: Ops & maintenance agent
│   ├── clawdyoda/                 # ClawdBot: Strategy & wisdom agent
│   ├── clawdsquishy/              # ClawdBot: Monitoring & alerts agent
│   └── shared/                    # 50+ shared modules for all bots
│       ├── coordination.py        # Multi-bot coordination protocol
│       ├── self_healing.py        # Auto-recovery from failures
│       ├── heartbeat.py           # Health monitoring heartbeats
│       ├── supermemory_client.py   # Supermemory knowledge graph
│       ├── knowledge_graph.py     # Local knowledge graph
│       ├── cost_tracker.py        # API cost tracking
│       ├── feature_flags.py       # Runtime feature toggles
│       ├── campaign_orchestrator.py # Cross-bot campaign management
│       └── ...                    # 40+ more modules
│
├── core/
│   ├── context_loader.py          # Shared Jarvis context/capabilities
│   ├── autonomy/                  # Autonomous intelligence modules
│   ├── memory/                    # Learning & memory systems
│   ├── security/                  # Key management, encryption
│   ├── price/                     # Multi-source price fetching
│   ├── risk/                      # Risk management
│   ├── cache/                     # API caching with TTL & decorators
│   ├── coordination/              # Task handoff & whiteboard
│   ├── metrics/                   # Bot metrics & aggregation
│   ├── health/                    # Health checker, monitor, reporter
│   ├── recovery/                  # Auto-recovery strategies
│   ├── scheduler/                 # Task scheduling
│   ├── plugins/                   # Plugin system with hooks
│   ├── di/                        # Dependency injection container
│   ├── integrations/              # Telegram, X/Twitter integrations
│   ├── observability/             # Monitoring & tracing
│   ├── validation/                # Input validation & sanitization
│   ├── notifications/             # Multi-channel notifications
│   ├── conversation/              # Session management & context
│   ├── audit/                     # Audit logging & retention
│   └── moltbook/                  # Trading journal system
│
├── tg_bot/
│   ├── bot.py                     # Main Telegram bot
│   ├── handlers/                  # Command handlers
│   └── services/                  # Chat responder, admin tools
│
├── api/
│   ├── server.py                  # RESTful API server
│   └── handlers/                  # API endpoints
│
├── jarvis-web-terminal/           # Next.js trading dashboard (NEW)
│   ├── src/app/                   # App router pages
│   └── src/components/            # React components
│
├── frontend/
│   ├── src/                       # React dashboard (legacy)
│   └── components/                # 70+ UI components
│
├── deploy/
│   ├── clawdbot-redundancy/       # Multi-bot Docker orchestration
│   │   ├── docker-compose.clawdbots.yml  # 5-bot stack
│   │   ├── Dockerfile.clawdbot-full      # Production image
│   │   ├── entrypoint.sh                 # Health-checked startup
│   │   └── scripts/                      # Self-healing automation
│   │       ├── peer-health-monitor.sh    # P2P health checks
│   │       ├── circuit-breaker.sh        # Cascading failure prevention
│   │       ├── nightly-backup.sh         # Automated backups
│   │       ├── brain-export.sh           # Portable brain export
│   │       ├── solana-wallet-init.sh     # Wallet initialization
│   │       └── self-evolution-reflect.sh # Nightly self-improvement
│   ├── *.service                  # systemd unit files
│   └── install-vps.sh             # VPS setup script
│
├── lifeos/
│   ├── config/                    # Configuration files
│   └── jarvis.py                  # LLM provider switch (Ollama support)
│
├── scripts/
│   ├── init_db.py                 # Database initialization
│   ├── health_check.py            # System health checks
│   ├── hetzner_api.ps1            # Hetzner Cloud management
│   └── db/migrate.py              # Schema versioning
│
├── tests/
│   ├── unit/                      # 200+ unit test files
│   ├── integration/               # Integration tests
│   └── framework/                 # Test utilities
│
├── deploy.sh                       # VPS deployment + systemd generator
└── kea-research/                   # Research workspace

---

🧠 The Portable Brain

One of Jarvis's unique features is the Portable Brain—a system that makes your AI context truly portable across devices, platforms, and even other AI systems.

What Is It?

The Portable Brain is:

• A unified memory format
• Cross-session context preservation
• Device-agnostic intelligence
• Exportable/importable knowledge base

How It Works

# Export your Jarvis brain
from core.memory.portable_brain import BrainExporter

exporter = BrainExporter()
brain_file = exporter.export_brain(user_id="you", output_path="my_jarvis_brain.json")

# Import to another device or system
from core.memory.portable_brain import BrainImporter

importer = BrainImporter()
importer.import_brain(brain_file="my_jarvis_brain.json", target_user="you")

What Gets Preserved

• Trading preferences and risk tolerance
• Learned patterns and habits
• Conversation history and context
• Model preferences and tuning
• Trust ladder progress
• Custom automations

This means:

• Switch devices seamlessly
• Backup your AI's knowledge of you
• Share context with other AI systems (future)
• Never lose your personalization

---

🤖 ClawdBots Multi-Agent Mesh

Jarvis v4.7 introduces ClawdBots — a distributed multi-agent system where specialized AI bots collaborate as a team.

The Agents

Shared Infrastructure

All ClawdBots share 50+ modules in bots/shared/:

• Coordination: Multi-bot task handoff, inter-agent protocol, whiteboard
• Self-Healing: Auto-recovery from failures, circuit breakers, health monitoring
• Memory: Supermemory knowledge graph, conversation memory, knowledge graph
• Observability: Heartbeats, cost tracking, logging, metrics
• Security: Allowlists, command blocklists, anti-hallucination guards

Deployment

# Docker: Deploy all 5 bots
docker compose -f deploy/clawdbot-redundancy/docker-compose.clawdbots.yml up -d

# systemd: Install as services on VPS
sudo bash deploy/install-clawdbots.sh

P2P Self-Healing

Bots monitor each other via peer health checks. If one bot goes down, others detect it and trigger recovery:

• peer-health-monitor.sh — Cross-bot health verification
• circuit-breaker.sh — Prevent cascading failures
• nightly-backup.sh — Automated state backups
• brain-export.sh / brain-import.sh — Portable brain transfer

---

💹 Trading Engine

Jarvis's trading engine is the most mature autonomous system in production today.

Architecture

Market Data → Sentiment Analysis → Signal Generation → Risk Check → Execution → Monitoring

Supported Exchanges

Strategies

81+ strategies across categories:

Risk Management

Position Sizing by Risk Tier

Stop Loss Rules

Active Monitoring

• Check Interval: 60 seconds
• Emergency Close: Positions down >90%
• Take Profit: Auto-close when TP hit
• Admin Alerts: Telegram notifications for all auto-closes

Circuit Breakers

---

🪙 Staking System

Earn SOL from Jarvis's trading profits by staking $KR8TIV.

How It Works

1. Stake $KR8TIV tokens
2. Trading Profits are collected in the treasury
3. 75% distributed to stakers proportionally
4. 5% to charity, 20% to development

Staking Tiers

Claiming Rewards

# Via Telegram
/claim

# Via API
POST /api/v1/staking/claim
{
  "user_id": "your_telegram_id"
}

---

💳 Credit System

For users who don't want to manage crypto, Jarvis offers a credit-based system with fiat payments.

How It Works

1. Buy Credits with credit card (Stripe integration)
2. Use Credits for trading, API calls, premium features
3. Auto-Conversion to SOL happens behind the scenes
4. No Crypto Knowledge Required

Pricing

Credit Usage

---

🎒 Bags.fm Integration

Real-time monitoring of bags.fm token graduations with automated investment analysis.

What It Does

• Monitors graduations in real-time via Bitquery WebSocket
• Analyzes tokens with Grok AI across 5 dimensions
• Generates intel reports with scoring breakdown
• Sends to Telegram for immediate review

Scoring Dimensions

Quality Tiers

Configuration

# Required
BITQUERY_API_KEY=your_bitquery_key

# Reuses existing keys
XAI_API_KEY=your_grok_key
TELEGRAM_BOT_TOKEN=your_telegram_token
TELEGRAM_BUY_BOT_CHAT_ID=your_chat_id

---

🏦 Treasury Management

The treasury is Jarvis's operational capital pool, managed autonomously with strict risk controls.

Current Treasury

Position Limits

Rebalancing

• Daily: Review and rebalance if drift >5%
• Weekly: Full portfolio audit
• Monthly: Strategy performance review

Emergency Controls

# Halt all trading
LIFEOS_KILL_SWITCH=true

# Close all positions
/emergency_close (Telegram admin command)

# Withdraw treasury
/withdraw <amount> <address> (requires 2FA)

---

🧬 Self-Evolution System

Jarvis learns and improves itself through a structured self-evolution system.

The Trust Ladder

Jarvis earns autonomy through successful actions:

Learning Loop

Observe → Predict → Act → Measure → Reflect → Improve

1. Observe: Collect data from actions and outcomes
2. Predict: Generate hypotheses about what will work
3. Act: Execute (within permission level)
4. Measure: Track success metrics (P&L, engagement, accuracy)
5. Reflect: Nightly analysis of what worked/failed
6. Improve: Update models, strategies, and behaviors

Memory System

Reflection Cycles

• Hourly: Performance metrics review
• Daily: Strategy effectiveness analysis
• Weekly: User satisfaction survey
• Monthly: Major architecture review

What Gets Learned

---

🤖 Intelligent Model Routing

Jarvis uses multiple AI models optimally routed based on task requirements.

Supported Models

Routing Logic

if task_type == "trading_decision":
    model = "grok"  # Sentiment-aware
elif task_type == "code_generation":
    model = "claude-3.5-sonnet"  # Best for code
elif task_type == "user_conversation":
    model = "gpt-4-turbo"  # Best general intelligence
elif privacy_required:
    model = "llama-3.1-70b"  # Local, no data leaves device
else:
    model = "mistral-large"  # Fast, cheap fallback

Cost Optimization

Ollama Integration

Run models locally with zero API costs:

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull models
ollama pull llama3.1:70b
ollama pull mistral:latest

# Jarvis auto-detects and uses local models

---

💬 Conversation Engine

Jarvis's conversation system is designed to feel natural, context-aware, and proactive.

Personality: "Smart Kid Who's Actually Cool"

• Tone: Calm, funny, helpful, edgy
• Style: Clear explanations, no jargon unless needed
• Humor: Self-aware, never mean
• Confidence: Admits uncertainty, asks clarifying questions

Voice Bible

Centralized in core/jarvis_voice_bible.py:

VOICE_PRINCIPLES = {
    "be_helpful": "Always prioritize user benefit",
    "be_honest": "Admit mistakes, uncertainty",
    "be_funny": "Humor without cringe",
    "be_clear": "No unnecessary complexity",
    "be_proactive": "Suggest improvements"
}

Context-Aware Tuning

Multi-Platform Consistency

The same voice principles apply across:

• Telegram messages
• Twitter/X posts
• API responses
• Voice commands
• Dashboard notifications

---

🔄 Cross-App Logic Loop

Jarvis runs a continuous logic loop across all platforms, ensuring consistent behavior and shared context.

The Loop

Telegram ↔ Context Engine ↔ Trading ↔ Twitter ↔ Web ↔ API

All components share:

• User preferences
• Active positions
• Market sentiment
• Recent actions
• Pending tasks

Example Flow

1. User asks in Telegram: "What's the market sentiment?"
2. Context Engine checks recent sentiment runs
3. If stale: Trigger new analysis
4. Trading engine provides position context
5. Twitter bot pulls recent crypto sentiment
6. Response synthesized from all sources
7. Sent to Telegram with actionable insights
8. Logged to memory for future reference

Cross-Platform Commands

Some commands work everywhere:

---

🎤 Voice Control

Control Jarvis hands-free via voice on desktop (macOS/Windows/Linux).

Capabilities

How It Works

1. Wake word: "Jarvis" or "Hey Jarvis"
2. Speech-to-text: Local Whisper model (privacy)
3. Intent classification: Determine command type
4. Execution: Route to appropriate handler
5. Text-to-speech: Respond with natural voice

Configuration

# Enable voice control
VOICE_CONTROL_ENABLED=true

# Wake word
VOICE_WAKE_WORD=jarvis

# Voice model
VOICE_MODEL=whisper-medium  # Options: tiny, small, medium, large

---

🌐 Cross-Platform Support

Jarvis runs on macOS, Windows, and Linux with platform-specific optimizations.

Platform Matrix

Installation Paths

Docker Support

Run Jarvis in Docker for easy deployment:

# Build
docker build -t jarvis:latest .

# Run
docker run -d \
  --name jarvis \
  -v ~/.lifeos:/root/.lifeos \
  -e TREASURY_LIVE_MODE=true \
  jarvis:latest

---

📊 Dashboard & Data Engine

The web dashboard provides real-time visibility into all Jarvis operations.

Dashboard URL

http://localhost:8080

Main Views

70+ UI Components

Data Engine

Real-time data processing pipeline:

Raw Market Data → Normalization → Storage → Analysis → Dashboard

---

🤖 Telegram Bot

Full-featured Telegram interface: @Jarviskr8tivbot

Core Commands

Admin Commands

Interactive Features

• Inline keyboards: Button-based navigation
• Live updates: Real-time position monitoring
• Sentiment reports: Hourly Grok analysis with trade buttons
• Bags Intel: Graduation alerts with quality scores
• Chart generation: On-demand price charts

Anti-Scam Protection

---

💼 Standalone Wallet

Jarvis includes a standalone wallet module for secure key management and transaction signing.

Features

Usage

from core.security.key_manager import KeyManager

# Initialize
km = KeyManager()

# Create new wallet
wallet = km.create_wallet(name="Trading Wallet")

# Load existing
wallet = km.load_wallet(name="Trading Wallet")

# Sign transaction
signed_tx = wallet.sign_transaction(tx)

Security

• Private keys never leave the device
• Encrypted with user-provided passphrase
• Optional 2FA for high-value transactions
• Transaction simulation before signing

---

🔌 Current Integrations

Jarvis integrates with 18+ external services:

MCP Integrations

18 Model Context Protocols configured:

---

🚀 Future Platforms

Jarvis is designed for multi-platform expansion:

Q2 2026

• iOS App: Native mobile experience
• Android App: Full feature parity with iOS
• Discord Bot: Community engagement, trading
• Slack Integration: Workplace notifications

Q3 2026

• Browser Extension: Chrome, Firefox, Edge
• Desktop App: Electron-based standalone
• CLI Tool: Command-line interface for power users

Q4 2026

• Smart Home: Alexa, Google Home integration
• Wearables: Apple Watch, Fitbit notifications
• AR/VR: Meta Quest, Vision Pro (experimental)

2027+

• Vehicle Integration: Tesla, CarPlay, Android Auto
• IoT Devices: Smart displays, security systems
• Robotics: Home assistant robots (experimental)

---

📡 API Reference

RESTful API for third-party integrations.

Base URL

https://api.jarvis.lifeos.ai/v1

Authentication

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.jarvis.lifeos.ai/v1/status

Core Endpoints

System

GET  /status              # System health
GET  /version             # API version
GET  /config              # Configuration (admin)
POST /shutdown            # Graceful shutdown (admin)

Trading

GET  /portfolio           # Current portfolio
GET  /positions           # Active positions
POST /trade               # Execute trade
POST /close/{id}          # Close position
GET  /strategies          # Available strategies
GET  /performance         # Trading stats

Sentiment

GET  /sentiment/current   # Latest sentiment
GET  /sentiment/history   # Historical data
POST /sentiment/analyze   # Analyze custom token

Staking

GET  /staking/balance     # Staked amount
POST /staking/stake       # Stake tokens
POST /staking/unstake     # Unstake tokens
POST /staking/claim       # Claim rewards
GET  /staking/rewards     # Unclaimed rewards

User

GET  /user/profile        # User profile
PUT  /user/preferences    # Update preferences
GET  /user/history        # Action history
GET  /user/stats          # User statistics

Rate Limits

Webhooks

Subscribe to events:

POST /webhooks
{
  "url": "https://your-domain.com/webhook",
  "events": ["trade.executed", "position.closed", "alert.triggered"]
}

---

🏗️ Architecture Deep Dive

High-Level Architecture

┌─────────────────────────────────────────────────────────────┐
│                     User Interfaces                          │
│  Telegram │ Web Dashboard │ Voice │ API │ Mobile (future)   │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                    Context Engine                            │
│  - Unified state management                                  │
│  - Cross-platform synchronization                            │
│  - User preferences & patterns                               │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                  Intelligence Layer                          │
│  GPT-4 │ Claude │ Grok │ LLaMA (local) │ Model Router       │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                    Action Domains                            │
│  Trading │ Social │ Productivity │ Devices (future)          │
└────────────┬────────────────────────────────────────────────┘
             │
┌────────────▼────────────────────────────────────────────────┐
│                   External Integrations                      │
│  Solana │ Jupiter │ Helius │ Grok │ APIs                    │
└──────────────────────────────────────────────────────────────┘

Component Interaction

┌──────────────┐
│  Supervisor  │ ◄────── Health Checks ──────┐
└──────┬───────┘                              │
       │                                      │
       ├──► Buy Bot (KR8TIV tracking)        │
       ├──► Sentiment Reporter (Grok)        │
       ├──► Twitter Bot (autonomous)     ────┘
       ├──► Telegram Bot (UI)
       ├──► Bags Intel (graduations)
       └──► Trading Engine (treasury)
                  │
                  ├──► Position Manager
                  ├──► Risk Manager
                  ├──► Execution Engine (Jupiter)
                  └──► Performance Tracker

Data Flow: Trading Decision

1. Market Data Ingestion
   ├─► DexScreener (price)
   ├─► Helius (on-chain)
   └─► Grok (sentiment)

2. Signal Generation
   ├─► 81+ strategies evaluate
   └─► Consensus scoring

3. Risk Check
   ├─► Position limits
   ├─► Liquidity check
   ├─► Risk tier classification
   └─► Circuit breaker state

4. Execution
   ├─► Jupiter quote
   ├─► Transaction building
   ├─► Signing (local wallet)
   └─► Submission (Helius RPC)

5. Monitoring
   ├─► Position tracking
   ├─► Stop loss checks (60s interval)
   └─► Performance logging

6. Learning
   ├─► Outcome recorded
   ├─► Strategy performance updated
   └─► Memory stored for future

Distributed Multi-Agent Architecture

For production scaling beyond a single server, Jarvis includes a distributed multi-agent architecture designed to scale from a single 32GB VPS to multi-node clusters serving millions of users.

Key Features:

• LangGraph supervisor for agent orchestration with human-in-the-loop approval
• NATS JetStream for sub-millisecond inter-agent messaging
• Ollama + LiteLLM for local inference with cloud failover (Groq → OpenRouter)
• Hybrid storage: Redis (hot state), Qdrant (vector memory), PostgreSQL (persistent data)
• Horizontal scaling: Phase 1 (1 VPS, 9-30 agents) → Phase 4 (Multi-cloud, 100+ agents)
• Cost-efficient: $70-100/month Phase 1 → $1,500/month at 1M users ($0.0015/user)

Scaling Phases:

Architecture Highlights:

• 30-60 LLM requests/min locally with sub-second latency for critical trading
• 80%+ cache hit rate for common queries
• Exactly-once delivery for trading signals via NATS JetStream
• Circuit breakers and retry policies for fault tolerance
• Multi-tenant isolation via PostgreSQL RLS and Redis key prefixing

For complete details on the distributed architecture, including deployment configurations, resource allocation, failover strategies, and implementation timeline, see:

📄 Distributed Multi-Agent Architecture

---

🧠 MCP & Semantic Memory System

What Is MCP?

Model Context Protocol (MCP) is a standardized way for AI models to access external data sources, tools, and services.

Jarvis uses 18 configured MCPs to:

• Access semantic memory (100+ learnings)
• Query databases directly
• Search code patterns
• Fetch API documentation
• Research web data in real-time

Memory Architecture

┌─────────────────────────────────────────────────────┐
│              Semantic Memory Store                   │
│  PostgreSQL (continuous_claude database)             │
│  - 100+ learnings with BGE embeddings                │
│  - 1024-dim vectors (bge-large-en-v1.5)             │
│  - Full-text search + vector similarity              │
└─────────────┬───────────────────────────────────────┘
              │
┌─────────────▼───────────────────────────────────────┐
│           Memory Importer (auto_import.py)           │
│  - Syncs PostgreSQL → Local SQLite                   │
│  - Generates JSONL for MCP server                    │
│  - Confidence ranking, topic filtering               │
└─────────────┬───────────────────────────────────────┘
              │
┌─────────────▼───────────────────────────────────────┐
│              Memory MCP Server                       │
│  - CLI: /recall skill in Claude Code                 │
│  - API: Python queries via MemoryImporter            │
│  - Search: Semantic + text-based                     │
└──────────────────────────────────────────────────────┘

Query Examples

from core.memory.auto_import import MemoryImporter

importer = MemoryImporter()

# Search by content
results = importer.search_imported_memories(
    query="trading strategy",
    limit=10
)

# Filter by confidence
high_confidence = importer.search_imported_memories(
    query="risk management",
    confidence_threshold=0.8
)

# Get statistics
stats = importer.get_memory_stats()
# Returns: {total: 105, by_type: {...}, by_confidence: {...}}

Learning Types

---

⚙️ Configuration

Environment Variables

Full reference: .env.example

Critical Settings

# Trading (REQUIRED for live trading)
TREASURY_LIVE_MODE=true
LIFEOS_KILL_SWITCH=false
MAX_POSITIONS=50
LOW_BALANCE_THRESHOLD=0.01

# Solana (REQUIRED)
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
HELIUS_API_KEY=your_helius_key

# Trading APIs (REQUIRED)
XAI_API_KEY=your_grok_key

# Social (REQUIRED for bots)
TELEGRAM_BOT_TOKEN=your_telegram_token
TELEGRAM_BUY_BOT_CHAT_ID=your_chat_id
TWITTER_BEARER_TOKEN=your_twitter_token
JARVIS_ACCESS_TOKEN=your_twitter_oauth

# Database (REQUIRED for memory)
DATABASE_URL=postgresql://user:pass@localhost:5432/jarvis

# Optional but Recommended
BITQUERY_API_KEY=your_bitquery_key  # For bags.fm
COINGECKO_API_KEY=your_coingecko_key  # For metadata

Feature Flags

# Enable/disable components
X_BOT_ENABLED=true
TELEGRAM_BOT_ENABLED=true
VOICE_CONTROL_ENABLED=false
WEB_DASHBOARD_ENABLED=true

# Safety features
REQUIRE_ADMIN_FOR_TRADES=true
ENABLE_CIRCUIT_BREAKERS=true
ENABLE_STOP_LOSS_MONITORING=true

---

🚀 Deployment

Production Deployment

Systemd Service (Linux)

# Recommended: run the automated deploy script (creates systemd units)
sudo bash deploy.sh

# Or enable services created by deploy.sh
sudo systemctl enable jarvis-supervisor
sudo systemctl start jarvis-supervisor
sudo systemctl enable jarvis-twitter jarvis-telegram

# Check status
sudo systemctl status jarvis-supervisor

# View logs
sudo journalctl -u jarvis-supervisor -f

deploy.sh generates the systemd unit files in /etc/systemd/system/ for jarvis-supervisor, jarvis-twitter, and jarvis-telegram. If you prefer a manual setup, use deploy.sh as the source of truth for unit definitions.

Docker Deployment

# Build image
docker build -t jarvis:4.6.5 .

# Run with docker-compose
docker-compose up -d

# Check logs
docker-compose logs -f

VPS Deployment

Recommended specs:

• CPU: 4+ cores
• RAM: 8GB+
• Storage: 50GB+ SSD
• Network: 100Mbps+

# Install dependencies
sudo apt update
sudo apt install -y python3.11 postgresql redis-server

# Clone and setup
git clone https://github.com/Matt-Aurora-Ventures/Jarvis.git
cd Jarvis
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Initialize database
python scripts/init_db.py

# Start supervisor
python bots/supervisor.py

Monitoring

Health Checks

# System health
curl http://localhost:8080/health

# Component status
curl http://localhost:8080/api/v1/status

# Metrics (Prometheus format)
curl http://localhost:8080/metrics

Log Locations

---

📋 Recent Updates

🚀 v4.6.6 - January 27, 2026

Self-Healing Resilience System & Cost Optimization

CRITICAL FIX: Bot Never Crashes When APIs Fail + 90% Cost Savings

New Resilient Provider Chain:

• Circuit breaker pattern with automatic failover
• Provider states: HEALTHY → DEGRADED → FAILED → RECOVERING
• Graceful degradation messages (never crashes)
• Background health monitoring with auto-recovery
• 3 failure threshold → circuit opens, 60s recovery timeout

Cost Optimization (Per User Request): NEW Priority Order:

1. Dexter (FREE via Claude CLI) - Default for Telegram ✅
2. Ollama (FREE, local) - Works offline
3. XAI/Grok (PAID) - Sentiment analysis only
4. Groq (FREE tier) - Backup for code/chat
5. OpenRouter (PAID) - Last resort

Savings: 90-95% cost reduction (from ~$5-10/day → ~$0.25-0.50/day)

EU/GDPR Silent Handling:

• GDPR notifications no longer logged as errors
• Rate limit auto-retry with 30s backoff
• Network errors handled gracefully
• safe_reply() and safe_edit() helpers

New Telegram Commands:

• /health - Show provider health status
• /vibe <query> - AI chat with resilient fallback

Files Added:

• core/resilient_provider.py - Provider chain with circuit breakers
• core/provider_health_monitor.py - Background health monitoring
• tg_bot/middleware/resilient_errors.py - EU/GDPR & error handling
• tg_bot/handlers/commands/health_command.py - Provider status
• tg_bot/handlers/commands/vibe_command.py - Resilient AI chat
• RESILIENCE_IMPLEMENTATION_GUIDE.md - Full integration guide

Expected Behavior:

• XAI down → automatic fallback to Ollama (FREE, still works!)
• EU notifications → silently handled
• Network timeouts → graceful retry
• 100% uptime guarantee with graceful degradation

🚀 v4.6.5 - January 21, 2026

V1 Stabilization & Critical Bug Fixes

Critical Telegram Bot Fix:

• Fixed infinite loop on Windows caused by duplicate lock acquisition
• Root cause: msvcrt.locking doesn't allow same process to lock file twice
• Bot was attempting lock at lines 228 AND 330
• Solution: Removed redundant acquire_instance_lock() call

Sentiment State Persistence:

• Moved record_sentiment_run() BEFORE Telegram posting
• State now saved even if downstream posting fails
• Prevents re-running sentiment on restart

Admin Check Fix:

• Fixed forward reference bug in bot_core.py
• DEFAULT_ADMIN_USER_ID now defined at top of file (line 123)
• Previously caused runtime errors (referenced at line 372, defined at line 2623)

Error Tracking Integration:

• tg_bot/handlers/__init__.py integrated with @error_handler decorator
• bots/supervisor.py now has track_supervisor_error() helper
• Coverage: ~20% of handlers, growing

New Features:

• Bags.fm Trade Adapter: Partner fee earning on trades
• Bags Intel Service: bags.fm graduation monitoring
• Dexter Sentiment: CLI interface for sentiment queries

🚀 v4.6.4 - January 17, 2026

Enterprise Memory & MCP Enhancement

18 Model Context Protocols Configured:

• ast-grep: 20x faster code pattern search
• nia: Instant SDK/API documentation
• firecrawl: Website scraping for market data
• postgres: Direct semantic memory queries
• perplexity: Real-time web research

Automated Memory Import System:

• Source: PostgreSQL continuous_claude database (100+ learnings)
• Storage: Local SQLite + JSONL for MCP server
• Access: Python API + CLI + /recall skill
• Search: Confidence-ranked, topic-filtered, semantic matching

New Files:

• MEMORY_QUERY_GUIDE.md - 50+ query examples
• MCP_SETUP_SUMMARY.md - Complete system documentation
• core/memory/auto_import.py - Memory import engine (398 lines)
• scripts/verify_mcp_setup.py - Setup verification tool

What This Enables:

• ✓ No knowledge loss between sessions
• ✓ Cross-session learning & pattern discovery
• ✓ 20x faster code search (ast-grep)
• ✓ Instant API documentation (nia)
• ✓ Real-time market research (perplexity + firecrawl)
• ✓ Semantic memory queries with 100+ learnings indexed

---

📚 Change History & Traceability

Full changelog: CHANGELOG.md

Version History

---

🗺️ Roadmap

Q1 2026 ✅ (Complete)

• ✅ Autonomous trading engine (81+ strategies)
• ✅ Telegram bot with admin controls
• ✅ Twitter/X autonomous posting
• ✅ Semantic memory system (100+ learnings)
• ✅ 18 MCP integrations
• ✅ Bags.fm graduation monitoring
• ✅ Self-evolution system with trust ladder
• ✅ ClawdBots multi-agent mesh (5 specialized bots)
• ✅ Peer-to-peer self-healing infrastructure
• ✅ Docker orchestration for multi-bot deployment
• ✅ Supermemory knowledge graph integration
• ✅ 50+ shared modules (coordination, self-healing, cost tracking)
• ✅ Next.js trading terminal (jarvis-web-terminal)
• ✅ Solana wallet initialization scripts

Q2 2026 (In Progress)

• 🔄 iOS & Android apps
• 🔄 Discord bot integration
• 🔄 Fiat payment processing (Stripe)
• 🔄 Multi-wallet support
• 🔄 Advanced backtesting dashboard
• 🔄 Custom strategy builder (no-code)

Q3 2026 (Planned)

• Productivity Domain: Calendar, email, task automation
• Communication Domain: Multi-platform messaging integration
• Device Control: Smart home integration (Alexa, Google Home)
• Voice Expansion: Multi-language support
• Browser Extension: Chrome, Firefox, Edge

Q4 2026 (Planned)

• Wearables: Apple Watch, Fitbit integration
• Vehicle Integration: Tesla, CarPlay, Android Auto (experimental)
• AR/VR: Meta Quest, Vision Pro (experimental)
• Robotics: Home assistant robots (research phase)

2027+ (Vision)

• Universal Assistant: Multi-domain intelligence (financial, health, productivity, social)
• Predictive Actions: Anticipate needs before you ask
• Complete Ecosystem: Your entire digital life, optimized and automated
• Physical Integration: Seamless interaction with real-world devices and systems

---

👥 Community

Official Channels

• Twitter/X: @Jarvis_lifeos
• Telegram: @Jarviskr8tivbot
• Discord: Coming Q2 2026
• GitHub: Matt-Aurora-Ventures/Jarvis

Token

• Symbol: $KR8TIV
• Blockchain: Solana
• Use Cases: Staking, governance, premium features
• Distribution: 75% holders, 5% charity, 20% development

---

❓ FAQ

General

Q: Do I need to know crypto to use Jarvis? A: No. You can use the credit system with fiat payments (credit card via Stripe). Jarvis handles all crypto operations behind the scenes.

Q: Is Jarvis free? A: Yes. The core system is open-source and free. Premium features (custom strategies, advanced analytics) require $KR8TIV staking or credit purchases.

Q: Does Jarvis send my data to third parties? A: Only what's necessary for operations (e.g., trades to Jupiter, sentiment to Grok). You can run local models (LLaMA via Ollama) for complete privacy. Your personal data never leaves your device.

Q: Can I run Jarvis locally? A: Yes. Jarvis runs on macOS, Windows, and Linux. You can even run it fully offline with local models (no internet required except for trading).

Trading

Q: How much can I start with? A: Minimum 0.1 SOL recommended. Treasury starts trading with 1+ SOL.

Q: What's the expected return? A: Past performance is not indicative of future results. Jarvis is designed to outperform holding, but crypto is volatile. Always risk what you can afford to lose.

Q: How does risk management work? A: Multi-layered:

• Max position size: 2% of treasury
• Risk-based position sizing (ESTABLISHED → SHITCOIN)
• Active stop loss monitoring (60s interval)
• Circuit breakers on consecutive losses
• Emergency close for positions down >90%

Q: Can I customize strategies? A: Yes. Gold/Platinum stakers can create custom strategies. Full no-code strategy builder coming Q2 2026.

Technical

Q: What languages is Jarvis written in? A: Python (backend), TypeScript/React (frontend), Solidity-like (Solana programs).

Q: Can I contribute? A: Yes! See CONTRIBUTING.md. We welcome:

• Bug reports
• Feature requests
• Code contributions
• Documentation improvements

Q: What databases does Jarvis use? A: PostgreSQL (main), SQLite (local cache), Redis (hot cache), TimescaleDB (time-series).

Q: Does Jarvis work on Raspberry Pi? A: Not officially supported, but possible for monitoring/alerts. Trading requires more compute.

---

🤝 Contributing

We welcome contributions from the community!

How to Contribute

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Make your changes
4. Run tests: pytest tests/
5. Commit your changes: git commit -m 'Add amazing feature'
6. Push to branch: git push origin feature/amazing-feature
7. Open a Pull Request

Code Standards

• Python: PEP 8, type hints, docstrings
• TypeScript: ESLint, Prettier
• Tests: 80%+ coverage for new code
• Documentation: Update README/docs for user-facing changes

Areas We Need Help

---

🔐 Security

Reporting Vulnerabilities

Do NOT open public issues for security vulnerabilities.

Email: security@lifeos.ai

Include:

• Description of vulnerability
• Steps to reproduce
• Potential impact
• Suggested fix (if any)

We aim to respond within 24 hours.

Security Best Practices

• Private keys: Never commit or share private keys
• API keys: Use environment variables, never hardcode
• 2FA: Enable for high-value operations
• Regular updates: Keep dependencies up to date
• Audit logs: Review system logs regularly
• Secret scan: Run python scripts/secret_scan_staged.py before pushes (last run: Jan 25, 2026)

---

📄 License

MIT License

Copyright (c) 2026 Matt Aurora Ventures

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

---

Jarvis: A persistent, personal context engine.
Starting with crypto. Building toward everything.

Twitter • Telegram • GitHub