The planning layer for coding agents
Your coding agent sees one repo. Your product lives everywhere else.
The docs, the designs, the tickets, the decisions, the recorded calls, the other repos: all of it is missing from your agent's view. Atelier maps your whole organization and hands the agent grounded specs to build from.
The problem
Every session starts from zero.
Point an agent at a single repository and it works blind. The context that makes the product make sense is scattered across tools and people, so the agent guesses, and you re-explain it every time.
- Context is scattered
- Code, docs, design, tickets, and recorded calls each live in a different tool. No single place holds the whole picture.
- The agent has no memory
- Every new session relearns the product from scratch. The context you provide never compounds.
- Specs drift from code
- Decisions get lost. What shipped slowly stops matching what was planned, and nobody can point to the source of truth.
The shift
From one repo to the whole organization.
Atelier connects every surface your product lives on and turns it into a navigable map. Your agent stops guessing and starts building from grounded specs.
- It never calls an LLM. The map is deterministic and git-tracked. Your agent does the thinking; atelier keeps the facts straight.
- It works with the tools you already use. Notion, Jira, Figma, GitHub. The agent does the I/O; atelier indexes the summary and the link.
- Everything is reviewable markdown. Diff it, review it in a PR, no black box.
How it works
Grounded at every step, from idea to shipped.
Atelier installs a pipeline of agents into your coding tool. Each step hands grounded, version-controlled artifacts to the next.
- /atelier:discovery
- Map the repos, docs, design, tickets, and people.
- /atelier:design
- Document the system architecture and the UI.
- /atelier:spec
- Turn a feature into right-sized specs. What is in, what is out, how you know it is done.
- /atelier:planning
- The approach, and the order to build it in.
- build
- Your agent ships from specs it can trust.
Why it matters
Built for the way teams actually work.
For enterprises
Scale the context, not the meetings.
- Onboard a new engineer or agent in hours, not weeks.
- Specs stay tied to the code they describe.
- Institutional knowledge survives turnover.
- Agent standards are shared and reviewed. They learn with your sign-off.
For startups
Move fast without losing the plot.
- The context in your head becomes durable and shareable.
- One command sets up your whole agent pipeline.
- Ship features your agent can build end to end.
- No lock-in. Everything is plain files in your repo.
Get started
Set up your agent in one command.
$ npm i -g @gilons-ai/atelier $ cd your-project $ atelier init --name "Your Product"
Then run /atelier:discovery in Claude Code. Works with Codex and Cursor too.