Plan the work together, before the Software Factory writes code

Spend time shaping the work instead of reviewing large AI-generated diffs. The factory drafts the scope, steps and risks, everyone on the team refines them in one multiplayer workspace, and agents build from the approved version.

Abstract translucent planes converge into one shared illuminated surface.

Trusted by teams operating AI in production

Capgemini logo
Vattenfall logo
hear logo
bunq logo
Moneybird logo
Yoco logo
Moss logo

Shape it together, sign off once, build from one plan

COLLABORATE

Bring every stakeholder into the same plan

Coding agents today are single player, with one engineer and one agent in a chat. In the Software Factory, engineering, security and product work on the same plan at the same time. Anyone can annotate a line with “clarify this”, “needs tests” or “consider alternatives”, and when the plan leaves something open, the agent asks, with a recommended option for each question.

Deployment invoke drops top_k and seed
Intent
Files to change
Steps
  1. Find where the builder drops the two parameters and keep them when the provider declares support.
  2. Forward seed to the OpenAI, Azure OpenAI, Groq and Mistral adapters.
  3. Forward top_k where an adapter already maps it, and leave new mappings to a follow-up.
  4. Assert both values on recorded requests for OpenAI and Groq.
Risks
  • Forwarding seed surfaces any adapter that names it differently.
Revision 1Revision 2
I need 2 decisions from you before I change the plan.
What should the deployment builder do when a provider rejects seed?
Drop seed for that provider (Recommended)
Keeps the request valid and logs the drop.
Fail the invoke
The caller sees the provider error.
Clamp seed to the provider range
Only Mistral needs it today.

APPROVE

Catch risks on the plan, then sign off

A missing test or security gap takes one comment to fix on the plan, but can mean redoing hours of agent work once it’s in a pull request. Each round of feedback creates a new revision, and the planning step can require a human to approve the final one before agents start building.

BUILD

Give agents and reviewers one source of truth

The approved plan is the brief every agent in the factory works from. Coding, QA and security agents build and test against it, and reviewers check the result against the same document. Review verdicts and failures feed the factory’s memory, so each new plan starts from what the last one taught.

Plan
Approved
Coding agent
Build from the plan
QA & security
Test against the plan
Reviewers
Check the same brief
Feedback
PlanRev.OpenOwner
Deployment invoke drops top_k and seedRev. 2–You
Add per-workspace rate limiting to the AI Gateway routerRev. 33Sam
Bound the OAuth callback retry and test itRev. 12Luis
Configurable guardrail timeout with its own errorRev. 21Luis
Reject deployment invokes that exceed the budgetRev. 11Sam

PROVE

Keep every decision on record

When an auditor asks why a change was made and who approved it, the answer is already there. Every plan keeps its revisions, comments, decisions and sign-offs under version control, ready as evidence for SOC 2, ISO 27001, DORA or EU AI Act audits.

FAQ

Frequently asked questions

Do we have to write and discuss plans in the Software Factory instead of our own tools?

The plan lives in the factory so the agent and your team can work on it together. The factory doesn’t replace Jira, Linear or Confluence, though. Each factory can write the approved plan back to the originating ticket or your wiki.

Who can see and comment on a plan?

Anyone with access to the factory can read a plan and give feedback on it. Work in a personal session stays private to you. Shared sessions are open to the team.

Can design and UX input be part of the plan?

Yes. Attach a Figma link or another artifact to the planning session, and the agent takes it into account while it drafts. Anyone with access to the factory, including UX, can annotate the plan.

Is human approval before coding mandatory?

You decide per factory. Any step in the pipeline can require human sign-off. For example, you can require approval of the plan and skip sign-off after code review, or the other way around.

How is this different from spec-driven development?

Spec-driven development writes the specification first and generates code from it. Collaborative Planning applies the same idea to each task. The agent drafts the plan, the team refines and approves it, and the approved plan guides every agent after it.

Put a governed Software Factory to work on your backlog

AI agents plan, build, test, review and monitor your software, inside your own guardrails. You set the direction and approve what matters.