Agentic Software Factory · v0.52.7

You describe. The factory builds. You approve.

You describe an application in your own words, AI agents such as Claude Code build it, the factory checks the result — and you approve. Behind it is a local control plane with supervised runs, Git discipline and an automatic quality check: reproducible, traceable, sign-off-able.

Current version
v0.52.7
Demo status
● LIVE
Wizard templates
19 templates
Quality gate
81 % / 85 %
Min. branch / line coverage

New · v0.52.7  The guided path: initial setup in three steps with a system check, describe your project in the quick start and click "Bauen" (build) — for existing projects too —, a run page that refreshes itself, and the result as a ZIP with a start command. Runs work in the background; "Einfach | Experte" sets how much you see. All news →

Three sentences and you have it
01 · DRAFT

From idea to plan.

You say in your own words what should be built — three inputs in the quickstart are enough, an existing project comes in via folder or Git address. The factory turns this into a clear task for the agent that you can read and change before the start. If you want to choose stack and checking tools yourself, use the detailed wizard with templates.

02 · RUN

From plan to code.

Runs work in the background; the run page shows progress, "Was jetzt?" (what now?) and the one button you need right now. Live logs, token and cost tracking and container sandbox. Build and scans run with hard limits (--cpus 2 --memory 4g --read-only by default, adjustable per project), the agent works in the project workspace (as a program on your machine, not in the container), every change is a commit. Browser notification when you need to make a decision.

03 · SIGN-OFF

From code to release.

Inline diff before every approval. Automatic quality gate from seven reviewer roles — Security, Architecture, Hallucination, dependency scan, spec conformance (only for runs with a spec), plus two vendor reviewers. No "Approve / Reject" blind flight, but findings split into blocking and advisory, with a confidence score per reviewer.

What it looks like

Describe, let it build, approve.

localhost:8080/wizard/schnellstart
The quickstart form: name, kind and description, then β€œBauen” (German UI)
Quickstart: three inputs in your own words, then “Bauen” (build).
localhost:8080/runs/…
The run page: status, progress, β€œWas jetzt?” and approval with one button (German UI)
Run page: progress, “Was jetzt?” (what now?) and approval with one button.
Your way in

Where do you want to start?

Try it

Demo in the browser

Click through a real instance without installing anything and without an account — with a guided tour.

Install it yourself

Single seat on your machine

Request the starter package, do your first run at no cost in the quickstart, then connect your subscription or API key.

For organisations

Enterprise

Tenants, roles, SSO, a signed audit chain and policy-as-code — Cloud, Self-Hosted or Air-Gap.

Pricing

Start free, grow when you need to.

You pay for the AI models directly to the provider. All limits and lease durations: Pricing →

Architecture whitepaper

Before the platform there was a 180-page deep dive.

Reference architecture, agent orchestration, guardrails and SDLC integration β€” as an architecture document, not a tool comparison. If you want to know why the factory is cut this way, start here.

Whitepaper page → Download PDF
Inside the factory

Why a factory — and not yet another chat?

Coding agents are already good at solving individual problems. They are bad at sticking to structure, cutting commits sensibly, getting reviews and checking their own output. The Software Factory takes those steps over — not the creative part.

The result: AI-assisted development that an architect can hand to a client without cleaning up the trail afterwards.

  • 01

    Per-role model routing

    With Claude Code, the Architect gets Opus by default, the Developer Sonnet, the Reviewer the lean, fast Haiku — saving tokens where quality isn't hurt and giving the strong model to the strategic roles. The mapping comes from the model catalog, can be overridden per team or via settings and is updated with factory releases.

  • 02

    Conductor writes the setup

    Before every run the platform writes .claude/settings.local.json and .claude/agents/<role>.md into the workspace. With the Claude Code project context switched on for the project, subagents are natively delegable without touching the CLI.

  • 03

    Container sandbox per run

    Optional: build and scans of the generated project run in an ephemeral Docker container with hard limits and a --read-only root, only the workspace is mounted. The agent itself runs with an ephemeral HOME free of foreign configuration.

  • 04

    Inline diff before approval

    At WAITING_FOR_APPROVAL the platform shows the final git diff. You see what the agent changed before you press the button.

  • 05

    Local cost estimate

    The wizard summary shows a token and EUR estimate — before the first run, without a vendor call. JTokkit computes locally.

Builder
Martin Janda
⌖ Author & architect

Martin Janda

Software architect with over three decades between mainframe (z/OS, Cobol, REXX) and cloud (Java/Spring, AWS, Azure, Kubernetes, microservices). In the frontend with Apache Wicket and Angular, in mobile founder of a German-speaking Xamarin community.

Certifications (selection): CKAD — Certified Kubernetes Application Developer (CNCF), AWS Certified Cloud Practitioner, Microsoft Certified: Azure Fundamentals (AZ-900), iSAQB CPSA-F (software architecture) and Oracle Certified Professional 12c.

The Agentic Software Factory is my attempt to embed AI agents into the software lifecycle in a way that makes them productive even under mid-market and compliance constraints — structured, traceable, sign-off-able rather than blindly generated.