We shipped apps with every popular framework. Hit the same walls every time. Eventually stopped complaining and started building. Six tools. All MIT. All because we needed them.
Death Legion Team is an open source group from Sri Lanka, operating as DEMO × HEXA. Six projects. Not trying to build an ecosystem or a brand. Just things we kept wishing someone had already made.
The mobile side started because we got tired of React Native and Expo lying to our faces. "Instant hot reload." We clocked it. Three seconds on a mid-range Android. Bundles that somehow weighed 400KB more than the app deserved. "Offline-first" that crashed the moment you went underground. So we built legionnative.
The AI side started for similar reasons. Every agent framework assumed you had a cloud budget and were fine with your data leaving the machine. LEGIONHERCULES fixes the local side — runs entirely on Ollama, free, forever, your hardware only. LEGIONGASPER handles the coordination problem — captain-agent pattern, parallel squads, five-layer memory — for when one model isn't enough.
The infra side came next. Deploying things shouldn't require three cloud accounts and a devops person. DEATHBASE gives you a serverless database that doesn't need a dashboard to configure. Legion-virtual handles isolated dev environments without the Docker ceremony. Legion-cloud is the deploy layer — push, and it runs.
All six exist because we needed them. Which probably means someone else does too. PRs welcome. Bug reports with reproduction steps even more so.
| Handle | deathlegionteamlk |
| Location | Sri Lanka 🇱🇰 |
| Alias | DEMO × HEXA |
| Projects | 6 active repos |
| License | MIT (all six) |
| Docs | legionhercule.pages.dev |
| Contributions | Open, always |
| Status | Active |
None of these started as portfolio pieces. They started as actual annoyances — things we were already building around before we decided to build them properly.
Give it a task. A captain agent breaks it up, recruits specialists, runs them in parallel, and hands you the result. You don't wire the handoffs.
LEGIONGASPER is a Python multi-agent AI system built around the coordination problem — the part where you end up babysitting three agents and manually stitching their outputs together. A captain agent handles decomposition, squad formation, and aggregation. You just describe the task.
The REST + WebSocket API lives on port 8081. There's a live dashboard at localhost:8080 — active agents, task queue, cost per provider, completion rates. All real-time. No polling.
Memory is the part that gets botched in most agent systems. LEGIONGASPER uses five layers so things don't get forgotten at the wrong moment: Session → Working → Daily → Long-term (ChromaDB) → Collective. Collective memory is shared across all agents — which matters when you're running multiple squads on related problems and need them to stop duplicating work.
# captain breaks task → recruits squad → runs parallel → merges captain = Captain(agent_id="research_lead") subtasks = captain.decompose_task("Analyze AI tooling market trends") squad = captain.form_squad(subtasks) results = await squad.execute_parallel() final = captain.aggregate_results(results)
Autonomous CLI agents that run 100% on your hardware. No API key. No cloud. No billing page. Pull a model once and run agents for free, permanently.
LEGIONHERCULES is not a chatbot with a tool call bolted on. The agents plan multi-step tasks, pick tools, execute them, read the results, and keep looping until done. The difference matters: a chatbot waits for you. These don't.
Five built-in tools cover most agentic work out of the box — file_read, file_write, file_edit, bash, web_search. The coder agent reads your files, edits code, runs the tests, and iterates. The researcher agent searches DuckDuckGo, reads pages, and summarizes — entirely hands-free. Multiple agents can run at the same time. Terminal UI is Rich. CLI is Typer.
# three commands, then you're running ollama serve ollama pull llama3.2 legionhercules chat --agent coder "Refactor main.py to use async/await" # switch model with a flag legionhercules chat --agent researcher --model codellama "Summarize latest LLM papers"
A mobile framework that doesn't lie about being fast. Every number in the table is a target, not a marketing claim — we're measuring, not guessing.
Born from shipping apps with Expo, React Native, and Flutter and hitting the same problems every time. The 3-second cold starts. Hot reload that claimed to be instant and wasn't. Bundles that grew 400KB when you added one dependency. "Offline-first" that really meant "cache one screen and pray."
TypeScript runtime. Rust core for the parts where JS is genuinely slow. Vite for development. Skia for rendering — same output across devices, not "mostly the same." WASM plugin system so you can drop native code in any language without leaving the build. Targets Android, iOS, and web from one codebase.
The metrics below are targets, not claims. We're working toward them in public. $100 Android phones are real. 3G networks are real. We're building for those too.
| Metric | Target | Why |
|---|---|---|
| Cold start | < 100ms | Users don't wait. They leave. |
| Hot reload | < 50ms | Actually instant. Measured, not claimed. |
| Base bundle | < 50KB | Downloads matter on slow connections. |
| Memory | < 20MB | Budget devices need to work. |
| Offline | Full | Real offline. Not one cached screen. |
A serverless database layer that doesn't require a dashboard, a DevOps person, or three config files to get running. Connect and query. That's the whole flow.
DEATHBASE started because every time we needed persistent storage in a small project, setting it up took longer than writing the actual feature. Supabase has too many tabs. PlanetScale needs a credit card to do anything useful. SQLite is great until you need it online. We bridged that gap.
Built on Cloudflare D1 under the hood — so it runs on the edge, globally, without you thinking about regions. The API is a thin REST layer over SQLite syntax. Create a table, insert rows, query them. No ORM required. Works from any language that can make an HTTP request.
# query your database from anywhere curl -X POST https://deathbase.pages.dev/query \ -H "Authorization: Bearer YOUR_TOKEN" \ -d '{"sql": "SELECT * FROM users WHERE active = 1"}' // or from JS — no driver needed const result = await fetch('https://deathbase.pages.dev/query', { method: 'POST', body: JSON.stringify({ sql: 'INSERT INTO logs (msg) VALUES (?)', params: [msg] }) })
Isolated development environments without the Docker ceremony. One command creates a virtual workspace that matches your prod config — no Dockerfiles, no docker-compose, no "it works on my machine."
The problem with Docker for local dev isn't that it's powerful — it's that you spend more time writing YAML about your environment than actually working in it. Legion-virtual handles the container spec for you. You describe what you need in plain English (or a minimal config), and it builds the environment.
WASM-backed sandboxing means environments are lightweight enough to spin up in under two seconds. You can have multiple active at once, switch between them instantly, and tear them down without cleanup debt. Works offline. No Docker daemon required on the host for WASM environments.
# create a Python 3.11 env with postgres + redis legion-virtual create my-env \ --runtime python:3.11 \ --services postgres redis # jump in legion-virtual enter my-env # list all running envs legion-virtual ls
Push code. It deploys. That's it. No cloud console, no IAM roles, no "click here to add a billing method." Just a CLI that knows how to get your thing running.
Legion-cloud is what happens when you get tired of cloud platforms treating deployment
as a product you have to learn rather than a problem you just need solved.
We wanted something closer to git push and farther from
"configure your load balancer health checks."
Built on Cloudflare Workers and Pages under the hood. Static sites, APIs, scheduled workers, and full-stack apps — all covered with the same deploy command. GitHub Actions integration means you can have continuous deployment working in under five minutes. No YAML templates to copy from Stack Overflow.
Pairs with DEATHBASE for storage and legion-virtual for local parity. The three together are close to a self-contained stack. None of them require you to talk to a sales team.
# deploy a static site legion-cloud deploy --type static ./dist # deploy an API worker legion-cloud deploy --type worker ./src/api # add a custom domain legion-cloud domain add api.yourproject.dev # set up CI with one flag legion-cloud ci --auto-deploy main
Not a philosophy. Just what's held true across all six projects.
Not aspirational. Not what we'd use if we started over. What's running right now.
Check the CONTRIBUTING.md in each repo before opening a PR — mostly to avoid duplicating work already in progress.