What is Tasker? Tasker is a specialized Task Management System built natively for AI Agents. In an advanced, autonomous Software Development Life Cycle (SDLC), traditional human-first issue trackers (like Jira or Trello) create immense friction for LLM-driven workers.
Why we are building it We are building Tasker to serve as the foundational task-and-knowledge infrastructure for high-scale AI and human collaboration. It allows AI agents to create, track, and update work internally via a highly optimized and secure Web API, bypassing clunky user interfaces.
By design, humans are primarily shifted "off the loop", empowered instead by a dedicated CLI and near real-time interactive web GUI. This allows managers to seamlessly step "on the loop" (for monitoring and feedback) or "in the loop" (for strict approvals) only when strictly necessary.
The Mission Scale This infrastructure is architected to scale aggressively, natively supporting:
- 20,000+ AI Agents running concurrent tasks.
- 20,000+ Human Users and Managers providing oversight.
- Complex hierarchy parsing up to 20,000 teams (with up to 100 members each), delivering 2,000 projects concurrently.
This codebase represents a multi-component system (housing a Backend, CLI, GUI, and shared contracts) structurally designed to be co-piloted by an advanced Agentic Autonomous Development ecosystem.
Instead of hiding tribal knowledge in developer heads, this repository is 100% declarative. Every architectural rule, coding convention, and product goal is explicitly mapped out in Markdown files, allowing AI agents to read, understand, and perfectly replicate our team's engineering standards.
All foundational context is stored entirely within the .specs/ directory.
These files explicitly govern what we are building and the overarching architecture:
- 🌍 Mission & Vision: The core product objectives and target user personas.
- 🛣️ Roadmap: Currently active milestones, planned epics, and timelines.
- 🏛️ Architecture: High-level system design (C4/DDD boundaries) and ADRs.
- 🛠️ Tech Stack: The exhaustive, hardcoded list of approved frameworks and tools (preventing agent hallucinations).
- 📓 Work Ledger: The strategic tracking router deciding if artifacts live locally or on external trackers (Jira/Linear).
These standalone rulebooks are injected seamlessly into our automated agent workflows via the standards-inject skill, ensuring generated code is consistently flawless.
- System Design:
api-standard.md|epic-standard.md - Frontend & Design:
frontend-standard.md|ui-ux-standard.md - Core Engineering:
coding-standard.md|security-standard.md|git-workflow-standard.md - Quality & Telemetry:
test-plan-standard.md|testing-standard.md|observability-standard.md
(View the programmatic catalog of all active rules in index.yml)
This project is built to execute the "Autonomous Epic Journey". Developers use lightweight /slash-commands to orchestrate specialized AI personas (Skills) that take features completely from Ideation -> Architecture Design -> Code Implementation -> Security Review.
To deeply understand how these isolated skills chain together, how they discover your newly written rules, and how they utilize token-efficient Context Injection: 👉 Read the Full Agentic System Overview
This project utilizes Moonrepo as its polyglot build system and task runner, backed by the proto toolchain manager. This ensures that every developer (and AI agent) automatically uses the exact same versions of Node.js, Bun, and Go without manual installation fighting.
You must install the Moon CLI globally. This will also install proto.
# Using bun
bun install -g @moonrepo/cli
# OR using the installation script (Mac/Linux)
curl -fsSL https://moonrepo.dev/install/moon.sh | bashOnce Moon is installed, navigate to the project root and run:
moon setupMoon will automatically read .prototools and locally download the exact, pinned versions of Node.js, Bun, and Go required for this project natively into ~/.proto.
You do not need to manually cd into directories to run scripts. Moon handles aggressive caching and dependencies automatically:
# Run the complete cached CI pipeline locally (lint, format, test, build for all apps)
moon check
# Run a specific task (e.g., build the React GUI)
moon run gui:build
# Run all tests across the monorepo simultaneously
moon run :testTo start the backend and GUI together for local development (backend runs in STANDALONE mode against an embedded SQLite database - no Docker/MySQL setup required):
moon run devThis tails both processes' logs in one terminal, prefixed [backend] /
[gui]; Ctrl-C stops both. The backend listens on :8080, the GUI dev
server on :5173.
To populate the local database with a realistic amount of data (an org, project, ~150 tasks, agents, labels) instead of starting from empty - useful for reproducing bugs that only show up once a list actually needs to paginate:
cd apps/backend && bun run seedThis prints a session token for the seeded user at the end; paste it into a
session cookie in the browser, or use it as a Bearer token with the CLI.
For investigating a specific problem once things are running - reading logs, checking a session token, inspecting the DB, confirming resolved config - see DEBUGGING.md.
Beyond the .specs/ configuration layer, the functional execution environment is organized as follows:
/apps/: Contains the specific application interfaces -cli,gui,backend./packages/: Contains shared foundational libraries and universal strict API contract definitions./.agents/: Houses the operational logic for our autonomous AI developer system (Skills and Workflows)./.epics/: Contains explicitly version-controlled feature packages (EPIC.md) currently in motion./.test-plans/: Houses all rigid, contractualGiven/When/Thenbehavioral expectations generated during planning phases.