Getting Started

Myca runs as a native desktop application (Electron) backed by a Python execution engine. Get up and running in under 5 minutes.

Download

Build from Source

# Clone the repository
git clone https://github.com/brienteth/myc-ai.git
cd myc-ai

# Start the AI backend
cd ai-layer
pip install -r requirements.txt
python main.py

# In a separate terminal — start the desktop app
cd desktop
npm install
npm run electron:start

System Requirements

The 5-Layer Architecture

Every Myca node is a self-contained participant in a peer-to-peer execution network. The stack is layered for isolation, security, and composability.

Layer 1: Discovery

Uses zeroconf (mDNS) to discover _myca._tcp.local. peers on LAN. Each node broadcasts its node_id, role (inference/storage/relay), load_pct, and model_shards. Dead nodes are garbage-collected after a 3-second heartbeat timeout. For WAN peers, Opacus H3 global registry provides signaling and WebRTC NAT traversal via STUN.

Layer 2: Connection

Local peers connect via HTTP/2 direct. Global (H3) peers use WebRTC DataChannel with STUN NAT traversal. Signaling happens through the Opacus H3 registry mailbox (POST/GET /api/registry/signal/{id}). Simulation mode uses asyncio.Queue message passing with 8-25ms configurable fake latency.

Layer 3: Coordination

The Orchestrator sends HTTP 103 Early Hints to all participating nodes before inference begins — storage nodes start fetching context, inference nodes load model shards. With 2+ nodes, model layers are split via tensor parallelism (Node A: layers 0-16, Node B: layers 17-32). Shard timeout at 200ms triggers one automatic retry.

Layer 4: Trust

PQC-ready encryption using X25519 ECDH key exchange + AES-256-GCM. Key rotation every 60 seconds; on failure, cached keys extend 30s. When liboqs ships for Python 3.14+, X25519 swaps to CRYSTALS-Kyber.

Layer 5: Inference

Pluggable backends via BackendRegistry: llamacpp (local GPU), ollama, 0g_compute (decentralized cloud), mock (testing), and remote (connect to another Myca node). Speculative inference optionally runs a fast draft model + verification model pipeline.

Resonance AI Core — Biomimetic Cognitive Engine

The Resonance AI Core is Myca's embedded local cognitive layer. Rather than routing raw text to resource-heavy cloud models, it combines native morphology parsing, hyperdimensional semantic memory, and deterministic verification to provide instant, sovereign intelligence on your device.

1. Morphogenetic Language Engine

Understands agglutinative grammar structures and contextual word formations directly on local hardware without cloud roundtrips.

2. Living Holographic Memory

A biologically-inspired memory architecture that adapts dynamically:

• Instant Retrieval: Fast local semantic recall across all personal knowledge items.
• Adaptive Retention: Active concepts are reinforced while obsolete contexts decay naturally.
• Contradiction Prevention: Identifies conflicting facts during memory ingestion.

3. Deterministic Reasoning & Execution

Mathematical calculations, structured queries, and policy rules are solved deterministically, eliminating model hallucinations while keeping power consumption minimal.

Planner v3 — Multi-Agent Execution Compiler

The Planner is not a prompt router. It is a deterministic Execution Compiler that decomposes user intent into validated, vendor-neutral execution graphs through an 11-stage multi-agent pipeline.

The 8 Quality Metrics

Every candidate graph is scored across 8 dimensions. Graphs below 96/100 are rejected and sent to the Repair Agent for iterative correction.

Sovereign Runtime — 12-Crate Rust Workspace

Myca's infrastructure layer is a pure Rust workspace with zero external service dependencies. No AWS. No Firebase. No third-party auth. Every protocol is owned and auditable.

Key Design Decisions

• Identity: Every device gets an Ed25519 keypair at first run. All inter-node messages are signed — no central identity provider.
• Storage: Content-addressed via Blake3 hashing with FastCDC chunking and Merkle DAG structures. Deduplication is automatic across the mesh.
• Transport: QUIC + HTTP/3 for low-latency, multiplexed connections. mDNS for LAN discovery, WebRTC for NAT-traversed global peers.
• FFI: PyO3 C-Extension bridge connects the Python Execution OS to the Rust Core. The Python layer handles orchestration; Rust handles performance-critical paths.

Colony — P2P Device Mesh

Colony is Myca's distributed compute layer. Every device running Myca — laptop, phone, cloud GPU — joins a peer-to-peer mesh where work is automatically routed to the most capable node.

How Devices Find Each Other

• LAN (Same Wi-Fi): mDNS broadcasts _myca._tcp.local. with TXT records containing node capabilities (VRAM, model shards, load %). Zero configuration required.
• WAN (Internet): Opacus H3 global registry at www.mycai.pro/api/registry provides signaling. Devices exchange WebRTC offers/answers via the H3 mailbox, then connect directly via DataChannel with STUN NAT traversal.

Tensor Parallelism

When a model doesn't fit on a single device, Myca automatically splits layers across mesh peers:

# Single device: all layers local
Node A: layers 0-32 (full model)

# Two devices: automatic split
Node A: layers 0-16
Node B: layers 17-32

# Activation flow: A computes → sends intermediate tensor → B completes

Compute Avoidance Hierarchy

Myca always resolves at the cheapest, fastest layer first:

Skills & Enterprise Drivers

Skills are the atomic execution units of Myca. Each skill is a self-contained module with a manifest, typed inputs/outputs, and built-in telemetry.

Built-in Skills

Skill Registry & Auto-Coercion

The SkillRegistry provides automatic discovery, telemetry tracking (usage count, failure rate, avg latency), and a Universal Auto-Coercion Layer that normalizes parameter names, converts data types, and handles synonyms — so skills always execute successfully regardless of how the Planner formats its output.

MCP (Model Context Protocol)

Myca supports Claude-compatible MCP servers. Connect any stdio or SSE MCP server to instantly register its tools as dynamic Myca skills. The MCP bridge handles protocol translation, so external tools appear native in the Planner's capability graph.

Enterprise Drivers

The Enterprise platform extends skills with organizational context. Drivers connect Myca to enterprise systems (SAP, Salesforce, Jira, Slack, AWS, Oracle) through a standardized BaseDriver interface. Each driver provides:

• Connection lifecycle management
• Credential resolution via Secrets Vault
• Ontology mapping (your business terms → driver APIs)
• Audit trail for every operation

Execution Intelligence v4

Execution Intelligence is the brain that sits between the Planner and the runtime. Instead of running a flat sequence of steps, it orchestrates Agents, Dependency Graphs, Parallel Execution, Verification, and Self-Healing Loops.

The Four Primitives

Budget & Policy Gates

Every execution has an ExecutionBudget with hard limits on cost, time, and token consumption. If the budget is exceeded, the engine performs a hard stop — no further nodes execute. This is enforced at the GraphRuntime level, before each node dispatch.

Live Execution Flow Playground

Experience Myca's Agent → Graph → Verify → Loop execution engine across 3 distinct real-world execution scenarios. Each frame demonstrates isolated multi-agent planning, governance, and output verification.

The 14 Development Phases

Execution Intelligence v4 was built incrementally across 14 phases — each one adding a production-ready capability to the Myca stack.

Enterprise Platform

Myca's enterprise layer provides the governance, visibility, and control that organizations need to deploy autonomous AI execution at scale.

Enterprise Domain Modules

Passkey Approval Queue

High-risk operations — SAP payments above $50k, AWS infrastructure scaling, Oracle DDL changes — require hardware Passkey/PIN approval before execution. The approval queue is embedded in the Execution Intelligence pipeline: the engine pauses at the approval gate and only resumes after biometric or PIN confirmation.

Policy Engine

Pre-execution policy checks for GDPR data sovereignty, SOX budget limits, and ISO27001 security controls. Policies are evaluated before the Planner commits a graph to runtime — violations block execution and surface actionable remediation steps.

Audit Trail

Every execution, approval, policy evaluation, and driver call is logged to an append-only audit trail with tamper-evident hashing. Exportable for compliance reporting.

Fiyatlandırma (Pricing) & Koltuksuz İş Modeli

"Myca doesn't charge for seats. It charges for work."

Geleneksel SaaS platformları ne kadar değer üretildiğine bakmaksızın kullanıcı/koltuk başına aylık lisans faturası keser. Myca fiyatlandırmayı çalışan sayısından bağımsızlaştırır ve doğrudan gerçekleştirilen iş yüküne (executed work) bağlar.

Hesaplama & Maliyet Katmanı Matrisi (Compute Tiers)

Fiyatlandırma Paketleri (Pricing Tiers)

Maliyet Hesaplama Formülü

Toplam İş Maliyeti = Platform Taban Ücreti + (Çalıştırma Sayısı × Execution Ücreti) + Compute Ücreti

* Not: Local (Kendi Donanımınız) üzerinde çalışan işlerde Compute Ücreti = $0.00'dır.

Work Economics & Economic Ledger DB

Myca'nın maliyet ve tasarruf takibi doğrudan Economic Ledger servisi (`myca/economics/ledger.py`) tarafından olay bazlı (event-driven) olarak yönetilir.

EconomicEvent Mimarisi

Execution Engine bir görevi çalıştırırken fiyat hesaplamakla vakit kaybetmez; olayları deftere (Ledger) kaydeder:

• ExecutionStarted: Görev başlatıldığında hedef ve tahmin bütçe kaydı.
• ComputeConsumed: Tüketilen GPU saniyesi ve token miktarının kaydı.
• VerificationCompleted: Bağımsız Verifier onay verdiğinde finansal değerleşme.
• ArtifactGenerated: Üretilen rapor/dosya çıktısının ekonomiye katılımı.

ExecutionOptimizer Algoritması

ExecutionOptimizer.evaluate(intent, requires_privacy) metodu, prompt geldiğinde 4 altyapıyı karşılaştırır ve en düşük gecikme/maliyet çiftini seçer.

Verified Savings Engine Formülleri

Workflows (İş Akışları) Rehberi

Myca Workflow Studio, niyetlerin (Intent) adım adım görsel düğümlere (Nodes) ve doğrudan yürütülebilir DAG grafiklerine dönüştürüldüğü ortamdır.

İş Akışı (Workflow) Mimarisi

4 Detaylı Üretim İş Akışı

1. Günlük Otonom Pazar Araştırması & Telegram Bildirimi

Amaç: Rakip sitelerin fiyatlarını sabah 08:00'de tara, sapmaları analiz et, Telegram'a gönder.

{
  "workflow_id": "market_research_daily",
  "trigger": { "type": "cron", "expression": "0 8 * * *" },
  "nodes": [
    { "id": "scrape_n1", "skill": "browser.scrape", "url": "https://competitor1.com" },
    { "id": "scrape_n2", "skill": "browser.scrape", "url": "https://competitor2.com" },
    { "id": "critic", "skill": "core.verify", "depends_on": ["scrape_n1", "scrape_n2"] },
    { "id": "notify", "skill": "communication.send", "target": "telegram", "depends_on": ["critic"] }
  ]
}

2. SAP ERP Ödeme Talimatı & Hardware Passkey Onayı

Amaç: Fatura tutarı $50,000 üzerindeyse biyometrik TouchID/Passkey PIN onayı alarak SAP'ye işle.

{
  "workflow_id": "sap_payment_approval",
  "policy": { "sox_limit": 50000 },
  "nodes": [
    { "id": "policy_check", "skill": "enterprise.policy_eval" },
    { "id": "passkey_gate", "skill": "enterprise.passkey_verify", "condition": "amount > 50000" },
    { "id": "sap_post", "skill": "enterprise.sap_driver", "depends_on": ["passkey_gate"] },
    { "id": "ledger_log", "skill": "economics.ledger_write", "depends_on": ["sap_post"] }
  ]
}

3. Çevrimdışı Doküman RAG & Bilgi OS Sentezi

Amaç: Yerel klasördeki PDF/Word dosyalarını Blake3 ile indeksle ve internete çıkmadan cevap üret.

4. Koloni P2P Mesh Model Katman Bölümleme

Amaç: 70B modeli iki yerel Mac cihazı arasında QUIC transport üzerinden katman katman böler.

Hazır Tarifler (Recipes)

Geliştiriciler ve sistem yöneticileri için hemen kopyalayıp kullanabilecekleri 6 hazır kod ve otomasyon tarifi.

Tarif A: Klasör İzleyici & Telegram Anlık Bildirim

from myca.sdk import Myca

async with Myca() as ai:
    # Watch desktop folder for new PDFs and auto-summarize to Telegram
    await ai.watch_folder("~/Desktop/Invoices", pattern="*.pdf", action="summarize_and_send_telegram")

Tarif B: Claude MCP (Model Context Protocol) Server Bağlama

# terminal
myca-cli mcp register --name github-mcp --cmd "npx -y @modelcontextprotocol/server-github"

Tarif C: Paralel Web Taraması ve Critic Agent Doğrulaması

from myca.execution.intelligence.engine import ExecutionIntelligenceEngine

engine = ExecutionIntelligenceEngine(inference_engine=None, secrets_vault=None)
plan = await engine.plan("Research competitor pricing and verify claims")

Tarif D: Özel Kurumsal Sürücü (Custom Enterprise Driver) Yazımı

from myca.execution.enterprise.drivers.base_driver import BaseDriver

class CustomCRMDriver(BaseDriver):
    async def execute(self, action: str, params: dict):
        # Implementation for custom internal CRM
        return {"status": "success", "crm_id": "CRM-9842"}

Tarif E: Biyometrik Passkey Onay Kapısı Entegrasyonu

from myca.execution.enterprise.approval_engine import PasskeyApprovalEngine

approval = await PasskeyApprovalEngine.request_approval(
    task_id="task_998",
    description="Transfer $75,000 via SAP Driver",
    risk_level="HIGH"
)

Tarif F: Spekülatif Çıkarım Motoru (Draft + Verify)

# .env ayarları ile hızlı taslak (Phi-3) + doğrulama (Llama-3.2) çift model çalıştırma
MYCA_SPECULATIVE=true
MYCA_DRAFT_MODEL=phi3:mini
MYCA_VERIFY_MODEL=llama3.2:3b

Python SDK

Embed Myca's execution engine into any Python application. The SDK provides a unified interface to LLM inference, web scraping, session memory, and the Software Factory.

from myca.sdk import Myca

async with Myca() as ai:
    # Text generation
    result = await ai.generate("Explain quantum computing in 2 sentences.")
    
    # Streaming
    async for token in ai.stream("Write a haiku about distributed systems"):
        print(token, end="", flush=True)
    
    # Embeddings
    vec = await ai.embed("Hello world")
    
    # Web scraping
    page = await ai.scrape("https://example.com")
    
    # Session memory (handover between sessions)
    await ai.handover("Today's progress", next_steps=["Write tests"])
    ctx = await ai.resume()

SDK Capabilities

Supported Backends

• llamacpp — Local in-process inference (Apple Silicon MLX / CUDA)
• ollama — Connect to local Ollama server
• 0g_compute — Decentralized compute via 0G Network
• remote — Connect to a running Myca node via HTTP
• mock — Lightweight test backend (no GPU needed)
• auto — Auto-detect best available backend

Benchmarks & Comparison

Myca vs. Alternatives

DePIN & Bare-Metal Silicon Kernel

Myca DePIN provides an ultra-lightweight, zero-heap (malloc=0) deterministic C99 micro-kernel purpose-built for bare-metal industrial microcontrollers (ARM Cortex-M0+/M4/M33, ESP32, and Raspberry Pi RP2350).

Hardware Benchmarks (ARM Cortex-M33)

Verified on Armv8-M cycle-accurate execution at 150 MHz (Raspberry Pi RP2350) and 250 MHz (STM32H5):

Deterministic C99 Micro-Kernel Architecture

// myc_kernel.h - Zero-Heap Industrial Safe-Sign Kernel
#ifndef MYC_KERNEL_H
#define MYC_KERNEL_H

#include <stdint.h>
#include <stdbool.h>

typedef struct {
    uint8_t  slave_id;
    uint8_t  function_code;
    uint16_t coil_address;
    uint16_t value;
    uint16_t crc16;
} ModbusFrame;

typedef struct {
    uint32_t execution_cycles;
    bool     is_negated;
    bool     pin_clamped;
    uint8_t  state_flags;
} SafeSignResult;

// Pure zero-heap deterministic guard - executed in 743 cycles
SafeSignResult myc_evaluate_intent(const char* intent, ModbusFrame* out_frame);

#endif

Modbus RTU & Industrial Register Mapping

The kernel calculates Modbus RTU CRC-16 polynomial 0xA001 directly in silicon registers, allowing direct integration with Siemens S7, Schneider Modicon, and MikroDEV PLC controllers without intermediate gateways.

Multi-Chain Hardware Settlement

Myca DePIN abstracts heterogeneous Web3 blockchains into a unified hardware oracle and settlement layer.

On-Chain Cryptographic Telemetry

Every physical actuator movement produces an immutable cryptographic state signature derived from the microchip's silicon Physical Unclonable Function (PUF) seed. Smart contracts can verify physical work with cryptographic certainty.

AI Agent Safe-Sign & Physical Actuation

Cloud AI Agents (Virtuals, Fetch.ai/ASI, ElizaOS, LangChain) possess high digital intelligence but lack physical embodiment. When LLMs control physical valves, turbines, or automated vehicles, hallucinations cause catastrophic physical damage.

The 6-Lock Safe-Sign State Machine

Autonomous M2M Micropayments

Two autonomous agents (e.g. an autonomous delivery drone and a decentralized solar charging station) negotiate and settle machine-to-machine micropayments in 38 microseconds directly on-chain without human credit cards or bank accounts.