tapestry

THIS IS THE PROJECT THAT PROVED WE CAN ORCHESTRATE AI AGENTS WITHOUT THE ENTERPRISE BLOAT.

something better :)

this is a lightweight, distributed orchestration engine for autonomous ai workers. the goal is simple: keep your logic in python (or whatever language you love) remove the headache of manually managing state make multi-agent systems feel native and easy

why this

i was looking at how people build "ai agents" today. most of them are just while-loops running on a single laptop. if the laptop closes, the agent dies. if you want two agents to share work, it's a nightmare.

what caught my attention was that the alternative is massive, enterprise service buses that take a week to configure.

that was the reason for me. so i built this rust-powered orchestrator to let agents be truly distributed, while keeping the developer experience stupid simple.

what it does

sits in the middle as a rust-based central nervous system holds tasks safely in a persistent sqlite database waits for workers to ask for jobs (polling) so no agent ever gets overwhelmed supports workers in any language (the demo uses python) gives you a live, real-time glassmorphic dashboard to watch the agents think runs the entire fleet instantly via docker compose

features

the core engine blazing fast concurrency built on rust (axum + tokio) simple rest api so any script can connect over http zero-config persistent state with sqlx

live telemetry ui premium dark mode with a canva-style dot grid live status badges that flip from pending -> in progress -> completed polling-based updates so you can watch the queue drain in real time

graph TD
    subgraph The Old Way: The Brittle Loop
        A[Your Laptop] -->|Runs| B(Agent Script)
        B --> C{Laptop goes to sleep?}
        C -->|Yes| D[Agent Dies. Task Lost.]
    end

    subgraph The Tapestry Way: The Distributed Fleet
        E[(Persistent SQLite)] --- F{Rust Orchestrator}
        F -->|Holds tasks safely| F
        
        G[Python Worker 1] -.->|Yo, got any work?| F
        H[Python Worker 2] -.->|I'm idle, send tasks!| F
        
        F ===>|Hands out Job #1| G
        F ===>|Hands out Job #2| H
    end
    
    style A fill:#2a2a2a,stroke:#555,color:#fff
    style B fill:#3b82f6,stroke:#2563eb,color:#fff
    style D fill:#ef4444,stroke:#dc2626,color:#fff
    style E fill:#10b981,stroke:#059669,color:#fff
    style F fill:#8b5cf6,stroke:#7c3aed,color:#fff

Loading

docker fleet spins up the rust hub + 3 python workers in exactly one command internal docker networking handles the routing automatically multi-stage rust builds keep the image incredibly tiny

tradeoffs

this is a broker, not a "brain." it routes the tasks perfectly, but the actual intelligence of the output still depends entirely on how cracked your python scripts are. right now it’s "first-come, first-served." it doesn't yet prioritize tasks based on specific agent "skills" (but skill-based routing is on the roadmap). it's built for agentic speed. if you need 100% ACID compliance across a massive global banking cluster, use kafka.

Setup (Local)

You only need Docker installed.

1. Clone the repo

git clone https://github.com/zumermalik/tapestry.git
cd tapestry

2. Launch the Fleet

docker compose up --build

3. Load the Dashboard
Open index.html in your browser (or use Live Preview in Codespaces). You'll see your 3 Python workers register themselves instantly.

4. Stress Test It In a new terminal, fire the canon:

chmod +x stress_test.sh
./stress_test.sh

how to use it well

keep the dashboard open on a second monitor, it looks insanely cool when it's running. start with the dummy tasks, but swap the python worker logic out for actual heavy lifting (api calls, llm processing, web scraping). use the stress test script to see how quickly your machine can handle concurrent ai generation.

notes

the dashboard uses dynamic url detection, so it works on localhost or codespaces automatically. if you stop the docker containers, your queue state is saved in tapestry.db. everything is editable. break it, fix it, make it yours.