v1.0.0 - Production Ready

Embedded AI Agent Swarm

A lightweight microkernel framework for distributed LLM inference on Jetson Orin Nano. 114KB binary, 100+ agents, zero-copy IPC.

Get Started View on GitHub

114KB

Binary Size

322

Tests Passing

<1μs

IPC Latency

100+

Agents

Jetson Orin Nano

CUDA + TensorRT

Everything You Need

A complete embedded AI framework with distributed inference, hardware acceleration, and enterprise-grade security.

Microkernel Architecture

114KB core with O(1) memory allocation, zero-copy IPC, and 7-state agent runtime.

CUDA & TensorRT

Flash Attention, LayerNorm, GELU kernels optimized for Ampere. FP16/INT8 precision.

Distributed LLM

Multi-agent coordination with mesh VPN. Pipeline and tensor parallelism support.

Security Hardened

Ed25519/RSA-PSS-4096/ECDSA-P256 signatures, secure boot, ASLR, stack canaries.

Power Management

DVFS with 7W/10W/15W profiles. Thermal throttling and fan control for Orin Nano.

100% Test Coverage

322 unit tests, HIL framework, benchmark suite, and penetration testing.

Layered Architecture

ClawSwarm follows a clean layered design with hardware abstraction at the bottom and application demos at the top.

Swarm Demo

Multi-agent coordination, visualization

Integration Layer

Distributed LLM, perf optimization, security

Extensions

LLM Bridge, Mesh VPN, Hardware Acceleration

ClawCore

Scheduler, memory, IPC, capabilities

Hardware Abstraction

POSIX, Jetson Orin Nano, ESP32

clawswarm.c

#include <clawswarm.h>

// Initialize the swarm
swarm_demo_context_t ctx;
swarm_demo_config_t config;
swarm_demo_get_default_config(&config);
config.agent_count = 16;
config.enable_tensorrt = true;

swarm_demo_init(&ctx, &config);
swarm_demo_start(&ctx);

// Submit inference task
swarm_demo_submit_inference(
    &ctx,
    "Explain quantum computing",
    128,  // max_tokens
    5,    // priority
    callback,
    NULL
);

// Get real-time metrics
swarm_demo_metrics_t metrics;
swarm_demo_get_metrics(&ctx, &metrics);
printf("Throughput: %.1f tok/s\n",
       metrics.swarm_throughput[0]);

Development Milestones

13 milestones completed. 322 tests passing. Production ready.

PHASE 1 ✓ Complete

ClawCore Foundation

✓ Scheduler & Memory
✓ IPC & Capabilities
✓ Agent Runtime
✓ Secure Boot & OTA

91 tests

PHASE 2 ✓ Complete

Extensions

✓ LLM Bridge
✓ Mesh VPN
✓ Hardware Acceleration

46 tests

PHASE 3 ✓ Complete

Integration

✓ Distributed LLM
✓ Performance Optimization
✓ Security Hardening

111 tests

PHASE 4 ✓ Complete

Hardware Bring-up

✓ Jetson Orin Nano BSP
✓ Swarm Demo
✓ Visualization Dashboard

74 tests

See It In Action

Run interactive demos to experience the swarm coordination.

Collaborative Inference

Multiple agents working together to process inference requests in parallel.


                        ./swarm_demo collaborative -a 16

Load Balancing

Dynamic task distribution with real-time load monitoring and rebalancing.


                        ./swarm_demo loadbalance -d 120

Fault Tolerance

Automatic recovery from agent failures with zero service disruption.


                        ./swarm_demo fault

114KB

Core Binary Size

Target: <200KB ✓

<1μs

IPC Latency

Zero-copy ring buffers

180

Tokens/sec

8 agents on Orin Nano

322/322

Tests Passing

100% coverage

Ready to Build?

Get started with ClawSwarm in minutes. Clone the repo, build with make, and run your first swarm demo.

# Clone the repository
git clone https://github.com/t4tarzan/clawswarm.git
cd clawswarm

# Build everything
make clean && make

# Run the swarm demo
./build/swarm_demo collaborative -a 16

Star on GitHub Read Tutorial