The agentic workspace where people and AI coding agents work together on every project.
Most of us aren't really writing code anymore, we're directing agents that do. But those agents have no memory. Every session starts from zero, and engineers end up spending their time re-explaining what was built, why decisions were made, and what still needs to happen. That's not engineering, that's babysitting.
Piyaz replaces that cycle. It's not just a context layer your agents read from, it's an agentic workspace where people and AI agents work together on the same project: project management, agent collaboration, and a shared context network in one place. Piyaz creates tasks, refines them, plans implementations, provides the right context at the right stage, and tracks everything that happens. Your agent harness doesn't need a briefing. It walks into every session knowing exactly what to do next and why.
Full setup, guides, and reference live at docs.piyaz.ai.
Use the hosted version (no clone)
Piyaz is hosted at app.piyaz.ai. The plugin installs into your coding agent once, at the user level, and works in every project you open, no clone required. Run the one-time install for your agent and sign in when prompted (OAuth, once per machine).
Claude Code
claude plugin marketplace add FrkAk/piyaz
claude plugin install piyaz@piyaz
Then run /mcp, select piyaz, and complete the browser sign-in.
Codex
codex plugin marketplace add FrkAk/piyaz
Open Codex, run /plugin, install Piyaz, restart, and authenticate when prompted. Invoke the main skill with $piyaz. (If your Codex build can't resolve the root marketplace, append --sparse plugins.)
Cursor
-
MCP only, any plan (quick start): open the install deeplink, then sign in on the first tool call:
cursor://anysphere.cursor-deeplink/mcp/install?name=piyaz&config=eyJ1cmwiOiJodHRwczovL2FwcC5waXlhei5haS9hcGkvbWNwIn0= -
Team/Enterprise (skills + MCP): Dashboard → Settings → Plugins → Team Marketplaces → Add Marketplace → Import from Repo, paste
https://github.com/FrkAk/piyaz. Team Marketplaces is a Teams/Enterprise feature. -
Public Marketplace: listing in the Cursor Marketplace requires submission and manual review. Search-and-install lands once Piyaz is published.
Antigravity
Add the Piyaz MCP server to your global config and authenticate (Antigravity handles OAuth automatically). The IDE and the CLI share one config at ~/.gemini/config/mcp_config.json (in the IDE: MCP Store → Manage MCP Servers → View raw config):
{
"mcpServers": {
"piyaz": { "serverUrl": "https://app.piyaz.ai/api/mcp" }
}
}
Then run /mcp (CLI) or open the MCP manager (IDE) and Authenticate. The workflow skills ship as a bundled plugin: clone this repo and copy plugins/antigravity/ into ~/.gemini/config/plugins/ (global) or .agents/plugins/ at your workspace root. The bundled mcp_config.json also includes a piyaz-local server for self-host.
Gemini CLI users: Antigravity replaces Gemini CLI (consumer access ends 2026-06-18). Run
agy plugin import geminito migrate, then use the Antigravity setup above.
Self-host / contribute
Self-hosting is free under AGPL-3.0. You run the Piyaz server yourself and point the plugin's piyaz-local server at it, no env vars required.
You need Bun (v1.0+) and Docker for PostgreSQL. Linux, macOS, or Windows with WSL2.
git clone git@github.com:FrkAk/piyaz.git
cd piyaz
bun install --production
cp .env.local.example .env.local
Fill in .env.local by following the numbered steps at the top of .env.local.example. Then bring up Postgres, build, start, and open localhost:3000:
bun run db:setup
bun run build
bun run start
Install the plugin for your agent as above, but select the piyaz-local server (it points at http://localhost:3000/api/mcp). Advanced self-hosters on a custom domain can set PIYAZ_URL to repoint the default piyaz server in Claude Code; Codex and Cursor read a hardcoded hosted URL, so edit their mcp.json directly if you need a custom domain.
Contributors install from the local checkout: claude plugin marketplace add ./plugins/claude-code (Claude Code), codex plugin marketplace add ./plugins (Codex), or copy plugins/cursor into ~/.cursor/plugins/local/. Shared skills live in plugins/claude-code/ (canonical); after editing them run bun run sync:plugins to regenerate every brand's copy (bun run check:plugins is CI-enforced).
What gets installed
All four plugins bundle the shared components:
| Component | What it does |
|---|---|
| 6 MCP tools | piyaz_project, piyaz_task, piyaz_edge, piyaz_query, piyaz_context, piyaz_analyze |
/piyaz skill |
Auto-invokes when conversation matches project planning; routes to inline workflows or hands off to a deep-mode workflow when needed |
| Brainstorm workflow | Explore and shape a project idea through structured conversation |
| Onboarding workflow | Reverse-engineer an existing codebase into a task graph with shipped work recorded as done |
| Decompose workflow | Break a project brief into a dependency graph |
| Manage workflow | Strategic CTO-mode review: rebalance the graph, audit dependencies, prune orphans, consolidate categories |
In Codex, Cursor, and Antigravity each workflow is a skill invoked by slash command. In Claude Code each is also available as a dispatchable agent (via the Task tool) so the main /piyaz skill can hand off work in a clean per-agent context.
Claude Code additionally bundles:
| Component | What it does |
|---|---|
/piyaz:composer skill |
End-to-end task orchestrator. Picks the highest-value ready task (or one named ref), drives it through research → plan → implement → review → propagate via a per-task workflow that dispatches phase subagents in clean per-phase contexts, merges the PR and continues when the user authorizes it, and loops until queue empty or user stops. Requires /goal harness for backlog mode (composer emits it on first turn; user pastes). |
| Composer subagents | piyaz:composer-researcher gathers grounded context and refines the task; piyaz:composer-planner writes the unabridged implementation plan; piyaz:composer-implementer ships the code, opens a PR, and marks the task in_review; piyaz:review returns the verdict that drives the bounded fix loop. |
piyaz:decompose-task agent |
Splits an existing oversize task in an active project into 2 to N children, rewires every dependency edge touching the parent, cancels the parent with rationale citing the children. Composer's oversize handler routes here. |
piyaz:decompose-feature agent |
Adds a new feature or capability cluster to an active project. Reuses existing categories and tag vocabulary; creates 5 to 20 tasks plus internal and integration edges. |
(Composer depends on a subagent dispatch primitive for clean per-phase contexts and tool-restriction enforcement. Codex, Cursor, and Antigravity do not yet have an equivalent, so composer is Claude Code only for now.)
How it runs
Piyaz ships as a Next.js web app plus vendor-native plugins for Claude Code, Codex, Cursor, and Antigravity. Each plugin bundles 6 MCP tools, the four core workflows (brainstorm, onboarding, decompose, manage), and a /piyaz skill that auto-invokes when you talk about projects, tasks, or planning. Claude Code adds end-to-end task orchestration via /piyaz:composer plus decompose-task and decompose-feature for surgical decomposition within active projects. You don't call tools manually, you just talk.
Three entry paths, one graph.
No project yet. The brainstorm agent shapes the idea with you, then decompose breaks it into a task graph:
❯ I want to build a real-time dashboard for server metrics
Existing codebase, no tracking yet. Onboarding reverse-engineers a graph from the code and git history, gated on your approval before anything is written:
❯ Onboard this existing codebase
Ongoing project. The /piyaz skill detects the repo and picks up where you left off:
❯ What's the status of the project?
Skip the context briefing. Name a task or ask what's next. Piyaz delivers the right bundle for that task's state, so you don't write "here's what you need to know" prompts yourself:
❯ What should I work on next?
❯ Plan and implement PYZ-101
Add and refine mid-flow. Spot something missing, describe it, and push back until it's right:
❯ Add a task for an onboarding agent that records shipped work as done tasks. Relate it to the codex/antigravity support task.
❯ Priority is urgent, draft ACs are enough, and monorepo detection should ask the user.
Drive end-to-end (Claude Code). Once a project is active and tasks are ready, composer can take over. Pick the next task off the critical path, research