How it works
The promise is simple: you own the architecture; your agents write the code. That's agentic engineering. Here's the workflow that delivers it: Agent-Native Development, the AND loop, end to end.
Windy runs an opinionated but powerful workflow for building with coding agents: state the intent, let the agent author a reviewable proposal, then move it through a task list, an execution, and a merged knowledge-base changeset. Humans decide; agents execute, one step at a time, over MCP.
What Windy is
Windy is not another coding agent. It is the workspace the coding agents you already have do their work inside. Humans use the web app to state intent, review proposals, comment, and merge. Agents use MCP to author proposals, run task lists, and stage knowledge-base changesets. Every write is attributed to the person who owns the endpoint.
The workflow
The Agent-Native Development lifecycle is a fixed sequence with human decision points as its gates. An agent never moves past a gate you haven't opened. This is the spine of the page: the full loop the homepage points here to see.
State what you want and pick a Work Type (Feature, Bug Fix, Refactoring, and more). The Work item is the container for everything that follows: its proposal, task lists, and executions.
Windy hands you a ready-to-paste author-proposal prompt for the Work Type you chose. Drop it into Claude Code, Codex, or any MCP-aware agent. No context to reconstruct, no tool to learn.
Working in the Work's proposal store, the agent expands your intent into an implementation spec/ (what to build) and a verification_spec/(how you'll know it works).
Read the proposal in the dashboard and leave inline comments. The agent answers the threads and revises. When it covers the intent and a fresh implementer could build from it, you mark it ready.
From the approved proposal the agent derives a changeset (a staged, git-commit-like edit to the knowledge base), or records that no doc change is needed. This gate stands between the proposal and the build.
The ready proposal becomes a Task List: ordered implementation and verification tasks, each with its own objective and acceptance criteria.
The agent runs the tasks as an Execution, committing per task and recording each commit SHA, then runs the verification specs. You watch progress task by task.
Review the code and the knowledge-base changeset together, comment or answer, then merge the changeset atomically into the knowledge base. The durable docs stay true to what shipped, and the next Work item starts from current truth.
The hand-off
Every workflow step has a copyable instruction the agent can pull straight from the workspace. Each one ends by naming the next step, so the workflow is self-chaining. The agent proposes what comes next, and picks it up on a plain “yes.” You stay the decision-maker; the prompts carry the method.
What the workspace holds
Work moves between a Work-scoped proposal store and the project's durable knowledge base, leaving a reviewable record at every step.
The project's long-lived specs, architecture, diagrams, schemas, and decisions: the design every agent reads before it builds. It only ever changes through a reviewed, atomically-merged changeset.
Each Work item has its own spec/ and verification_spec/the agent authors and you review. It's separate from the knowledge base, so half-finished thinking never pollutes the durable docs.
A ready proposal, decomposed into ordered implementation and verification tasks, each with an objective and acceptance criteria you can steer before anything runs.
The run record for a Task List: per-task status, a commit SHA for each task, and a verification summary. A clear, auditable trail from intent to shipped code.
Reviewed, git-commit-like edits to the knowledge base. Staged during the build, reviewed alongside the code, and merged atomically, so the docs move with the change instead of lagging behind it.
Inline comments on proposals and changesets, from humans and agents. Threads an agent can answer make reviewing AI work a conversation, not a rubber stamp.
The proposal store is where work is drafted. The knowledge base is where it lasts.
See it in practice
No new tool, no copy-paste of context. Drive the whole workflow from Claude Code, Codex, or any MCP-aware agent: open a Work item, author the proposal, build it, and merge, all in one session.
Boundaries
Windy gives coding agents a design to build from and a workflow to run. The developer still decides what should be built, reviews every step, and owns the result.
Security & control
Each MCP endpoint is per-(user, project): bound to one person and one project. Every change an agent makes through it is attributed to you, with a clear audit trail across proposals, executions, and changesets.
Learn more
Evergreen guides to agentic engineering, MCP, and spec-driven development.
Start with one project, connect your agent over MCP, and run your first Work item: proposal, review, task list, and merge, all in one place.
windylogic.ai