Piranha Agent 🐟

Next-generation autonomous agent framework with Rust core, radical transparency through time-travel debugging, Wasm sandboxing, and 53+ skills (46 Claude + 5 Explorer + 2 Planning).

🛡️ Human-in-the-Loop & Supervised Autonomy

Piranha is designed for Supervised Autonomy. We believe that while agents should be fast, they must never be "black boxes."

• The Autonomy Speed Gap: Piranha executes core operations at 51K+ ops/sec. Without oversight, errors can scale instantly. We provide the infrastructure to stop, audit, and intercept actions.
• Accountability Engine: Our "Time-Travel Debugger" provides a cryptographic-ready audit trail. Every LLM decision is recorded in our Rust-backed EventStore for full forensic analysis.
• Enterprise-Grade Hardening: Built-in protection against credential leaks, unauthorized network access, and unsafe code execution.

🔒 Security Hardening (Production-Ready)

We have implemented multiple layers of defense to make Piranha safe for production deployment:

1. Production-Grade Wasm Sandbox

Unlike competitors who run generated code directly on the host, Piranha uses Wasmtime to execute code in a strictly isolated environment.

• Enforced Limits: Memory, CPU (fuel), and execution time are strictly capped.
• No Host Access: Isolated from the file system and environment by default.
• Performance: 7M+ validations/sec

2. Fine-Grained Permission Enforcement

Skills now verify agent permissions before execution using Python contextvars.

• Authoritative Validation: Even if an LLM tries to call a sensitive tool, the skill itself will refuse to run if the agent lacks the specific permission tag.
• Wildcard Support: Simple * permission for development, restrictive tags for production.

3. Egress Hardening (Network Protection)

Prevent data exfiltration with built-in network guardrails.

• Allowed Hosts Whitelist: Restrict agents to communicating only with trusted domains (e.g., github.com, internal-api.company.com).
• Validated Skills: Core skills use the validate_url() helper to intercept and block unauthorized outbound requests.

4. Secret Masking (Auto-Redaction)

Protect credentials from ending up in logs or UIs.

• Regex Scrubbing: Automatically detects and redacts OpenAI keys (sk-...), GitHub tokens, and Bearer tokens.
• Keyword Masking: Dictionary keys like password, secret, and api_key are scrubbed before storage.

🤖 Autonomous Agent Orchestration (v0.4.2)

Piranha now supports autonomous multi-agent "teams" managed by a Coordinator agent, similar to Claude Code's agent swarms.

Dynamic Delegation

The Coordinator can autonomously "hire" specialized sub-agents and assign them tasks.

Shared Environment

Teams share a Message Bus for inter-agent communication and a Shared State (whiteboard) for collective memory.

Orchestration Skills

Built-in skills for delegate_task, get_team_status, and broadcast_message.

Example:

from piranha_agent.orchestration import create_orchestrated_team

team = create_orchestrated_team("research-team")
# Coordinator delegates tasks autonomously
# Sub-agents collaborate via shared message bus
# Results aggregated automatically

Documentation: docs/CLAUDE_CODE_SWARM.md | docs/ARCHITECTURE.md

🚀 Quick Start

# Install from source
git clone https://github.com/piranhabot/piranha-agent.git
cd piranha-agent
python3 -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

# Install Ollama for local LLM
ollama pull llama3:latest

# Run your first agent
python examples/01_basic_agent.py

✨ What Makes Piranha Different?

🏆 5 Pillars of World-Class Agents

🚀 Unique Differentiators

🏆 Ranked #1 vs competitors - See Framework Comparison | World-Class Features

📦 Complete Feature Set

Phase 1-9: 100% Complete ✅

🏗️ Architecture

graph TD
    subgraph "Clients & Tools"
        CLI[Piranha CLI]
        UI[Piranha Studio / Debugger]
        NC[No-Code Builder]
        VS[VS Code Extension]
    end

    subgraph "Python SDK (Safety & Orchestration)"
        Agent[Agent / AsyncAgent]
        Collab[Multi-Agent Collaboration]
        Bus[Shared Message Bus]
        State[Shared State / Whiteboard]
        Memory[MemoryManager / Semantic Search]
        Mask[SecretMasker]
    end

    subgraph "Rust Core (High-Performance)"
        ES[EventStore / Audit Log]
        Wasm[WasmRunner / Wasmtime]
        SR[SkillRegistry / Auth]
        SC[SemanticCache / Fuzzy]
    end

    subgraph "External Systems"
        LLM[Ollama / Anthropic / OpenAI]
        DB[(PostgreSQL / SQLite)]
    end

    %% Connections
    CLI --> Agent
    UI --> ES
    NC --> Agent
    VS --> Agent

    Agent --> Collab
    Collab --> Bus
    Collab --> State
    Agent --> Memory
    Agent --> Mask

    Agent --> LLM
    Agent --> SR
    Agent --> SC
    Agent --> Wasm
    
    ES --> DB
    SC --> ES
    Memory --> LLM

🆕 NEW: Architecture-First Workflow (Plan Mode) v0.4.2

Enforce architectural thinking before code execution with the new plan_first parameter:

from piranha_agent import Agent

agent = Agent(name="architect")

# Plan Mode: Agent MUST draft PLAN.md before acting
result = agent.run_autonomous(
    task="Build a REST API",
    plan_first=True  # ← Forces planning workflow
)

How it works:

1. Agent drafts PLAN.md with architectural strategy
2. Human reviews and approves the plan (HITL checkpoint)
3. Agent executes according to approved plan
4. Progress tracked against plan milestones

New Skills:

• draft_plan - Write architectural strategy (requires confirmation)
• get_plan - Retrieve and review current plan

Benefits:

• ✅ Prevents rash code changes
• ✅ Enforces architectural thinking
• ✅ Creates audit trail (PLAN.md)
• ✅ Human oversight for complex tasks

🆕 NEW: Claude Code Explorer Integration (v0.4.2)

Explore Claude Code's 512K+ lines of source code directly from your Piranha Agents!

from piranha_agent import Agent
from piranha_agent.claude_code_explorer import create_claude_explorer_skill

# Create agent with Claude Code Explorer skills
agent = Agent(
    name="claude-code-expert",
    skills=create_claude_explorer_skill(),
)

# Explore Claude Code internals
result = agent.run("Show me how BashTool works in Claude Code")
print(result)

Features:

• ✅ List all 40+ Claude Code agent tools
• ✅ Explore 50+ slash commands
• ✅ Read source code for any tool/command
• ✅ Search codebase with regex patterns
• ✅ Get architecture documentation

Requirements: pip install mcp

Full Documentation: docs/CLAUDE_CODE_EXPLORER.md | Example

🎯 53+ Skills Available (46 Claude + 5 Explorer + 2 Planning)

Piranha includes the largest collection of pre-built AI skills:

📊 Complete Skill Breakdown

📚 Full catalog: skills/CATEGORIZATION.md | docs/SKILLS_REGISTRATION.md

🛠️ Installation

Prerequisites

• Python 3.10+
• Rust (install via rustup)

Quick Install

# From source
git clone https://github.com/piranhabot/piranha-agent.git
cd piranha-agent
python3 -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

Verify Installation

python -c "from piranha_agent import Agent; print('✓ Piranha installed!')"

📖 Usage

1. Basic Agent with Local LLM

from piranha_agent import Agent, Task

# Create agent with Ollama and strict security
agent = Agent(
    name="assistant",
    model="ollama/llama3:latest",
    permissions=["basic_math", "knowledge_base"],
    allowed_hosts=["localhost", "wikipedia.org"]
)

# Run a task
result = agent.run("Explain quantum computing in simple terms")
print(result.content)

Full example: examples/01_basic_agent.py

Using any other local model: Piranha's model="ollama/<name>" works with any model Ollama can serve - not just llama3. Pull it, then point an agent at it:

ollama pull hermes3:8b   # or qwen3, mistral, deepseek-coder, any Ollama model

agent = Agent(name="assistant", model="ollama/hermes3:8b")

This also covers models fine-tuned with Unsloth (LoRA/QLoRA training with 2x speed and 70% less VRAM) - Unsloth exports trained models in GGUF format, which loads into Ollama like any other model (ollama create my-model -f Modelfile, then model="ollama/my-model"). Unsloth itself is a training tool, not something Piranha calls at runtime; the fine-tuned model is what gets connected, the same way as any other local model above.

2. Async Agent with Claude Skills

import asyncio
from piranha_agent import AsyncAgent as Agent
from piranha_agent.complete_claude_skills import register_complete_claude_skills

async def main():
    # Create async agent
    agent = Agent(
        name="skilled_assistant",
        model="ollama/llama3:latest",
        permissions=["*"], # Wildcard for full access in development
    )

    # Register ALL 46+ skills
    register_complete_claude_skills(agent)

    # Run research autonomously
    result = await agent.run("Research the latest in AI safety")
    print(result.content)

if __name__ == "__main__":
    asyncio.run(main())

Full example: examples/10_official_claude_skills.py

3. Wasm Sandbox for Safe Code Execution

from piranha_agent import WasmRunner

# Create Wasm runner
runner = WasmRunner()

# Validate Wasm module
wasm_bytes = bytes([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00])
is_valid = runner.validate(wasm_bytes)

# Execute safely in sandbox
result = runner.execute(
    wasm_bytes=wasm_bytes,
    function_name="main",
    input="test input"
)
print(f"Success: {result['success']}, Time: {result['execution_time_ms']}ms")

Full example: examples/07_wasm_sandbox.py

4. Semantic Memory with Real Embeddings

from piranha_agent import MemoryManager, EmbeddingModel

# Use real semantic embeddings with SQLite-based persistence
model = EmbeddingModel(provider="ollama", model="nomic-embed-text")
memory = MemoryManager(
    embedding_model=model,
    persist_path="my_agent_memory.db" # Memory survives restarts!
)

# Accurate semantic retrieval
memory.add("Piranha uses a Rust core for extreme speed")
results = memory.search("Is this framework fast?")
print(results[0][0].content) 

Full example: examples/08_semantic_cache_fuzzy.py

5. Accountability Engine (Time-Travel Debugger)

# Launch transparency UI
piranha-agent debug

Features:

• Forensic Replay: Step through every LLM decision and tool call.
• Decision Provenance: Trace exactly why an agent chose a specific path.
• State Rollback: Revert the agent to a pre-error state for safe intervention.
• Audit Reports: High-speed export of all system events for compliance.

6. Multi-Agent Collaboration (Shared Message Bus)

from piranha_agent import Agent
from piranha_agent.collaboration import MultiAgentCollaboration, AgentRole

# Create collaboration with Shared Message Bus
collab = MultiAgentCollaboration()

# Add agents
collab.add_agent(Agent(name="researcher"), AgentRole.RESEARCHER)
collab.add_agent(Agent(name="writer"), AgentRole.WRITER)

# Agents communicate asynchronously via the bus
collab.message_bus.publish("research.start", "manager", "Starting market analysis")

# Run complex tasks with shared state (whiteboard)
await collab.execute_task("Build a comprehensive market report")

7. Real-Time Monitoring & Benchmarking (Piranha Studio)

# Launch Studio with Benchmarking Dashboard
piranha-agent monitor

Features:

• Shared State: All agents access a common "whiteboard" for complex coordination.
• Message Bus: Topic-based Pub/Sub for asynchronous multi-agent communication.
• Visual Benchmarks: Real-time charts for Throughput and Latency (P95/P99).
• Performance Tracking: Compare different LLM models and detect regressions visually.

Full example: examples/11_piranha_studio.py

8. Observability & Metrics

from piranha_agent import ObservabilityManager, init_observability

# Initialize observability
obs = init_observability(
    service_name="piranha-agent",
    otlp_endpoint="http://localhost:4317",  # Jaeger
)

# Track requests
with obs.track_request("agent_chat"):
    obs.record_token_usage(
        model="llama3",
        prompt_tokens=100,
        completion_tokens=50,
        cost_usd=0.002,
    )

# Export Prometheus metrics
prometheus_metrics = obs.metrics.export_prometheus()

# Check for cost anomalies
anomaly = obs.cost_detector.record_cost(0.01)  # Detects 10x normal cost

Full example: examples/09_observability.py

9. No-Code Visual Builder

from piranha_agent import create_nocode_ui

# Launch visual builder
ui = create_nocode_ui()
ui.launch()

# Open at http://localhost:7861
# Features:
# - Drag-and-drop workflow builder
# - Pre-built templates
# - Auto-generate Python code
# - One-click deployment

📊 Framework Comparison

Piranha vs Leading Frameworks

Last fact-checked: August 2026. Feature marks below are based on each project's public docs/repo, not on Piranha's own claims. "Performance" is a relative, unverified self-assessment — see [Performance Benchmarks](#-performance-benchmarks) below for Piranha's own measured numbers.

¹ AutoGen and Semantic Kernel are both officially in maintenance mode as of 2026 — Microsoft merged both into Microsoft Agent Framework (GA'd April 2026), which is now their actively developed successor. Comparing against them as current "leading frameworks" is somewhat academic; MAF is the fairer comparison point going forward.

² CrewAI's CodeInterpreterTool sandbox is Docker-based, not Wasm, and had critical 2026 CVEs (CVE-2026-2275, CVE-2026-2287) where it silently fell back from Docker to a bypassable mode enabling RCE — worth knowing if you're evaluating CrewAI's sandboxing specifically.

Note: the "AgentGen" framework previously listed here could not be identified in any current search — no project by that name was found, so the column was removed rather than left unverifiable.

Additional Frameworks

More frameworks worth knowing about, checked against the same criteria (except Performance, which we haven't independently benchmarked for these):

³ Agno was formerly known as Phidata.

⁴ Not to be confused with "OpenAI Swarm" (a different, deprecated project) — Agency Swarm is a separate, actively maintained project built on the OpenAI Agents SDK.

🏆 Overall Scores (self-assessed composite for the originally-compared frameworks only; see methodology — the newer additions above haven't been run through this scoring yet):

1. Piranha Agent - 9.2/10 🥇
2. Microsoft Agent Framework - 8.8/10 🥈
3. DeepAgents - 8.6/10 🥉
4. LangGraph - 8.5/10
5. Pydantic AI - 8.3/10
6. Semantic Kernel - 8.0/10 (maintenance mode)
7. AutoGen - 7.5/10 (maintenance mode)
8. CrewAI - 7.0/10

Detailed comparison:

• vs All Frameworks
• vs Microsoft Frameworks (AutoGen, Semantic Kernel, MAF)
• vs DeepAgents - Full feature breakdown
• Detailed Scores Breakdown

📈 Performance Benchmarks

Single-run numbers from `python tests/test_benchmarking.py` on one development machine - not an average, not independently audited, and not stable. Verified August 2026 by running the suite 3x back-to-back on the same machine: the sub-millisecond benchmarks (SkillRegistry Authorize, Wasm Validate, SemanticCache Get) varied by 3-6x between runs, since at that timescale the "work" being timed is smaller than OS scheduler/timer noise. Only the benchmarks with real measurable latency (EventStore Append, SemanticCache Put, Vector Search) were stable (~1-2% run-to-run). Treat the fast numbers below as "very fast," not as a precise figure - rerun the suite yourself if you need current numbers.

There is no competitor benchmark anywhere in this repo - the tests/test_benchmarking.py suite only measures Piranha's own components. An earlier version of this section claimed "50-100x faster than competitors," which had no actual comparative test behind it; removed rather than corrected, since there's nothing to correct it to. See How to test it and score it below if you want to reproduce or extend this.

¹ SemanticCache.put() computes a real embedding via a local Ollama call (nomic-embed-text) to support fuzzy matching, so it's network-bound - this replaced an earlier hash-based placeholder embedding that had no actual semantic meaning (and inflated this number to ~643K ops/sec). get() by exact key doesn't call the embedding model and stays fast.

🔁 How to Verify These Benchmarks Yourself

# Run once
python tests/test_benchmarking.py

# Run a few times back-to-back to see the actual variance
for i in 1 2 3; do python tests/test_benchmarking.py 2>&1 | grep -E "^Benchmark:|Throughput:"; echo; done

📊 Visual Benchmarking

You can view these benchmarks in real-time using Piranha Studio:

1. Start the monitor: piranha-agent monitor (or python -m piranha_agent.realtime --port 8080 directly)
2. Run benchmarks with reporting: PIRANHA_MONITOR_URL=http://localhost:8080 python tests/test_benchmarking.py
3. Open http://localhost:8080 and click the Benchmarks tab to see live charts.

📁 Project Structure

piranha-agent/
├── piranha/                  # Python SDK
│   ├── __init__.py           # Main exports
│   ├── agent.py              # Agent implementation
│   ├── async_agent.py        # Async support (89% coverage)
│   ├── llm_provider.py       # LiteLLM integration (100% coverage)
│   ├── observability.py      # Tracing/Metrics/Alerting
│   ├── nocode_builder.py     # Visual workflow builder
│   ├── memory.py             # Vector memory
│   ├── debugger.py           # Time-travel debugger
│   └── [10+ skill files]     # 46+ Claude Skills
├── rust_core/                # Rust Core
│   ├── src/
│   │   ├── event_store.rs    # Event sourcing
│   │   ├── skill_registry.rs # Skill management
│   │   ├── guardrails.rs     # Safety guardrails
│   │   ├── semantic_cache.rs # Fuzzy cache
│   │   ├── wasm_runner.rs    # Wasm sandbox
│   │   ├── postgres_store.rs # PostgreSQL backend
│   │   └── distributed_agents.rs # Distributed agents
│   └── Cargo.toml
├── debugger_api/             # FastAPI backend
├── debugger_ui/              # React + ReactFlow UI
├── studio/                   # Real-time monitoring
├── vscode-extension/         # VS Code integration
├── skills/                   # Skills Documentation
│   ├── README.md
│   └── CATEGORIZATION.md
├── docs/                     # Documentation
│   ├── FRAMEWORK_COMPARISON.md
│   ├── MICROSOFT_FRAMEWORK_COMPARISON.md
│   └── IMPROVEMENT_ROADMAP.md
├── examples/                 # 14 Working Demos
│   ├── 01_basic_agent.py
│   ├── 02_skills.py
│   ├── 03_multi_agent.py
│   ├── 04_rust_core.py
│   ├── 05_ollama_local.py
│   ├── 06_complete_features.py
│   ├── 07_wasm_sandbox.py
│   ├── 08_semantic_cache_fuzzy.py
│   ├── 09_observability.py
│   ├── 10_official_claude_skills.py
│   ├── 11_piranha_studio.py
│   ├── 12_validation.py
│   └── 13_benchmarks.py
├── tests/                    # Test Suite (223 tests)
│   ├── test_rust_core.py
│   ├── test_python_sdk.py
│   ├── test_wasm.py
│   ├── test_semantic_cache_fuzzy.py
│   ├── test_benchmarking.py
│   └── [more...]
├── README.md                 # This file
├── LICENSE                   # MIT/Apache-2.0
└── pyproject.toml            # Project configuration

🧪 Testing

# Run all tests (223 passing)
pytest

# Run specific test suite
pytest tests/test_wasm.py -v
pytest tests/test_async_agent.py -v

# Run performance benchmarking suite
python tests/test_benchmarking.py

# With coverage
pytest --cov=piranha --cov-report=html

Current Status: 223/223 tests passing, 3 skipped ✅

Code Quality: 96/96 findings fixed (100% resolved) ✅

Cost Optimization

Piranha's semantic cache with fuzzy matching can reduce LLM costs by 30-50%:

🔒 Security Features

• Wasm Sandbox: Isolated code execution (no host OS access)
• Guardrails: Token budget enforcement
• Permissions: Fine-grained skill permissions
• Audit Log: Full event sourcing for compliance
• No Secrets: API keys never stored in code

🤝 Contributing

Contributions are welcome! Here's how to help:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Setup

# Clone and setup
git clone https://github.com/piranhabot/piranha-agent.git
cd piranha-agent
python3 -m venv .venv
source .venv/bin/activate

# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check .
mypy piranha/

# Build
maturin develop --release

Please read our Contributing Guide for details.

📚 Documentation

Core Documentation

• [Skills Catalog](skills/CATEGORIZATION.md) - Complete skills list by category
• [Framework Comparison](docs/FRAMEWORK_COMPARISON.md) - vs DeepAgents, LangGraph, CrewAI, AutoGen
• [Microsoft Comparison](docs/MICROSOFT_FRAMEWORK_COMPARISON.md) - vs AutoGen, Semantic Kernel, MAF
• [Improvement Roadmap](docs/IMPROVEMENT_ROADMAP.md) - Future development plans
• [Implementation Guide](IMPLEMENTATION_COMPLETE.md) - Full implementation details
• [Agent Rules](RULES.md) - What agents should/must/must not do

Security & Quality

• [Security Guide](docs/SECURITY.md) - Comprehensive security documentation
• [Security Hardening](docs/SECURITY_HARDENING.md) - Security hardening guide
• [Code Quality Status](docs/CODE_QUALITY_STATUS.md) - 96 findings fixed, 100% resolved
• [Perfect Code Quality](docs/PERFECT_CODE_QUALITY.md) - Code quality journey

Testing & Validation

• [Complete Release Summary](docs/COMPLETE_RELEASE_SUMMARY.md) - v0.4.0 release summary
• [Final Test Status](docs/FINAL_TEST_STATUS_93_PERCENT.md) - 93.4% test pass rate
• [Wiring Validation](docs/WIRING_VALIDATION.md) - System validation report
• [Backend UI Audit](docs/BACKEND_UI_AUDIT.md) - Feature audit

Performance & Benchmarks

• [Performance Benchmarks](tests/test_benchmarking.py) - Run benchmarks
• [Wasm Tracking](docs/WASM_TRACKING.md) - Wasm execution tracking
• [UI Guide](docs/UI_GUIDE.md) - UI components guide

Development

• [New UI Features](docs/NEW_UI_FEATURES.md) - Latest UI additions
• [Empty Except Fixed](docs/EMPTY_EXCEPT_FIXED.md) - Error handling improvements
• [Final Code Cleanup](docs/FINAL_CODE_CLEANUP.md) - Code cleanup summary
• [Dependabot Update](docs/DEPENDABOT_UPDATE_COMPLETE.md) - Security updates

🗺️ Roadmap

🆕 What's New in v0.4.1?

Corrected August 2026: this section was mislabeled "v0.4.0" - the security hardening, Piranha Studio, and No-Code Builder items below all shipped in v0.4.1 per [CHANGELOG.md](CHANGELOG.md). See the sections above for what shipped in the current v0.4.2 (Plan Mode, Claude Code Explorer).

Security Enhancements 🔒

• ✅ Environment-based SECRET_KEY - No more hardcoded defaults
• ✅ Fail-closed API key verification - Secure by default
• ✅ Improved exception handling - Better error messages
• ✅ Updated deprecated APIs - Python 3.12+ compatible
• ✅ Security hardening module - Comprehensive security utilities

Code Quality Improvements 📊

• ✅ 96 code quality findings fixed - 100% resolved
• ✅ 169 passing tests - 93.4% test pass rate
• ✅ Zero linter warnings - All issues resolved
• ✅ PEP 8 compliant - Professional code quality
• ✅ Thread-safe concurrent tests - Race conditions fixed
• ✅ Configurable performance thresholds - CI/CD friendly

New Features 🎉

• ✅ Piranha Studio - Real-time monitoring dashboard
• ✅ No-Code Builder - Visual workflow builder
• ✅ Enhanced observability - OpenTelemetry integration
• ✅ Comprehensive benchmarks - 7M+ ops/sec performance
• ✅ Better documentation - 24+ technical docs

Bug Fixes 🐛

• ✅ Fixed ReDoS vulnerabilities in regex patterns
• ✅ Fixed unreachable code issues
• ✅ Fixed unused variables and imports
• ✅ Fixed WebSocket authentication
• ✅ Fixed sync/async task execution
• ✅ Fixed event type safety issues

📄 License

This project is licensed under the MIT License OR Apache-2.0 License - see the LICENSE file for details.

🙏 Acknowledgments

• [Anthropic](https://github.com/anthropics/skills) - Claude Skills inspiration
• [ComposioHQ](https://github.com/ComposioHQ/awesome-claude-skills) - Awesome Claude Skills collection
• [LiteLLM](https://github.com/BerriAI/litellm) - LLM provider integration
• [PyO3](https://github.com/PyO3/pyo3) - Python-Rust bindings
• [Wasmtime](https://github.com/bytecodealliance/wasmtime) - Wasm runtime
• [React Flow](https://github.com/xyflow/xyflow) - DAG visualization
• [Gradio](https://github.com/gradio-app/gradio) - No-code UI
• [OpenTelemetry](https://opentelemetry.io/) - Observability standards

🤝 Community & Contributing

We welcome contributions of all kinds! Please check out these resources to get started:

• [Contributing Guide](CONTRIBUTING.md): How to set up your dev environment and submit a PR.
• [Code of Conduct](CODE_OF_CONDUCT.md): Our expectations for community behavior.
• [Support Guide](SUPPORT.md): Where to get help and how to report issues.
• [Changelog](CHANGELOG.md): Stay up to date with the latest changes.

📬 Contact

• GitHub Issues: Report bugs or request features
• Discussions: Join the conversation
• Documentation: Full docs

🌟 Quick Links

Made with ❤️ using Rust + Python

Last updated: April 2026 | Version: 0.4.2 | Status: Production Ready