Frequently asked questions.

What is the Agentic Software Factory?

A local web application that lets you kick off, supervise and trace AI-assisted development in a structured way. It connects project capture (with or without the wizard), automatic generation of Markdown specifications, run orchestration against coding CLIs (Claude Code, Codex, Gemini, Kimi, Aider), live logs, Git discipline and an automatic quality gate. The goal is not „magic AI coding with one click“ — it's reproducible, reviewed results you can hand to your team.

Who is the platform for?

Primarily for software architects, lead developers, technical project managers and small teams who want to do AI-assisted development in a more controlled, reproducible way — typically in mid-sized companies, regulated industries, or consultancies that have to document code outcomes. It's not meant as a mass consumer product and isn't aimed at hobbyists who want to generate a quick script — Claude Code on its own is faster for that.

What's the main difference vs. Claude Code in the shell?

With direct shell use you have to organise project definition, guardrails, approvals, Git discipline and status oversight manually. The Software Factory makes those aspects visible and reusable — you don't kick off one coding pass, you orchestrate a sequence of plan, implement, review and validate, with live logs and a quality-gate verdict at the end. It's not a different coding mode, it's a different abstraction layer.

What's the best way to get started?

Without installing: the demo with a guided tour. Installed yourself: request the single-seat starter package, then the quickstart (10 minutes, mock adapter, no AI costs). After that set up real runs and play through the tutorial with Claude Code.

How do I install the platform locally?

With the single-seat starter package. It is available on request (contact). After that you request the Community license directly in the factory — or import a Professional or Enterprise license file. The factory runs natively on your machine, only the database in a container. Click by click in the quickstart; self-hosted and air-gap are available via Enterprise.

What are the prerequisites?

• Java 25 and git.
• Docker (Desktop or Engine) for the database.
• Free ports 8080 (factory) and 5432 (Postgres, bound locally only).
• For real runs the CLI of your AI agent (e.g. Claude Code) with a subscription or API key — not for the mock adapter.

The starter package contains install-softwarefabrik.sh (WSL/Linux/macOS) and install-voraussetzungen.ps1 (Windows); they check Java 25, git, git-lfs, Docker and the Claude Code CLI and install what is missing after asking. Toolchains for your projects (JDK, Maven, .NET SDK, Node.js, Go, uv) are installed by the factory itself since v0.45.0 under Einrichtung → Werkzeuge (setup → tools).

Do I need API keys?

For the local demo the mock adapter is enough — no keys. For real vendor calls you need an API key or a subscription login of the agent CLI. The easiest way is to enter the key in the initial setup (Einrichtung → KI-Zugang, setup → AI access); the factory checks it right away. Anthropic / OpenAI / Gemini keys are persisted encrypted — there or in the /integrations view (AES-GCM, master key from SOFTWAREFABRIK_SECRETS_MASTER_KEY).

What is the mock adapter for?

The mock adapter is a test adapter that works without an API key and writes deterministic pseudo tokens into the workspace. Ideal for:

• First platform tests: quickstart, onboarding without vendor cost.
• CI pipelines: when you want to test the platform mechanics, not the LLM.
• Bug reproduction: if a run shows weird logs, you can replay it with mock without burning real tokens.

Output is not „real code“ — more like pseudo content that simulates a typical run flow.

How much does the platform cost?

Community is free. Professional costs 20–30 €/month per user, Enterprise starts at 20,000 €/year (Self-Hosted and Air-Gap as individual contracts). What costs extra are vendor API costs (Anthropic, OpenAI, Google) for actual coding calls — the platform only acts as a broker there.

What are the Community tier limits?

The limits of the Community license — runs per day, agents, machines per e-mail address, duration — are collected on the pricing page, together with how runs are counted. No support SLA and no spec-driven development; tenants, roles, SSO and audit chain are included.

What data is sent to external servers?

In the default setup only:

• To the license server: license ID (UUID), device fingerprint hash (SHA-256), email hash, client version, ISO country of the IP.
• To the version lookup (Maven Central, GitHub, npm): just unauthenticated HTTP GETs.
• Only when an ADMIN installs a toolchain under “Einrichtung → Werkzeuge”: unauthenticated downloads from the vendors' sources (Adoptium, Apache, Microsoft, nodejs.org, go.dev, GitHub for uv). Can be switched off with softwarefabrik.werkzeuge.installation-erlaubt=false.
• To the configured LLM vendor: your prompt + workspace contents. Depends on the vendor.

In air-gap mode: nothing. Details in the transparency document.

What has changed since the beginning?

In short: the MVP with two wizard templates has grown into a tool for the whole development cycle — iterative development with branch/PR, quality gate, tenants and roles, an attested audit chain, spec-driven development and a build gate for many stacks. Every release with full notes is on the news page.

What problems does the platform solve?

• Too few or unstructured commits during AI-assisted coding.
• Lack of transparency around logs, status and approvals.
• Inconsistent project definitions across teams.
• Hard to reuse good project setups (start from scratch every time).
• High manual effort orchestrating multiple coding CLIs.
• Missing automated quality assessment of AI-generated output.

What agent roles are envisaged?

Seven roles: Architect, Developer, Reviewer, QA, Security Reviewer, Documentation and Merge/Release. Each role can have a preferredModel — an Architect might use claude-opus-5-5 for deep design decisions, a Developer the faster claude-sonnet-5-5. Roles are serialised as Markdown into AGENTS.md and read by the coding agent as context.

What's a typical workflow?

1. Once, as administrator: „Ersteinrichtung starten“ (start initial setup) on the dashboard — choose the AI agent and subscription or API key, fix the open points of the system check, get going.
2. Describe the project: „Neues Projekt“ (new project) → quick start (name, kind, description) and „Bauen“ (build) — this creates the project and starts the first run. For an existing project: „Bestehendes Projekt weiterentwickeln“ (develop an existing project) with folder or Git address and task, then „Importieren und bauen“ (import and build).
3. Follow the progress on the run page (it refreshes itself); at Wartet auf deine Freigabe (waiting for your approval) look at the changes and click „Freigeben und fortsetzen“ (approve and continue). The „Was jetzt?“ (what now?) box names the next step.
4. After Abgeschlossen (COMPLETED) look at the „Ergebnis“ (result) card: start command under „Selbst ausprobieren“ (try it yourself), ZIP download; in expert view, if needed, „Quality-Gate ausführen“ (run quality gate) and review findings.
5. Continue with „Weiter verbessern“ (keep improving) or „Nächster Auftrag“ (next task) on the project page, or „Vorschläge machen lassen“ (get suggestions, a plan run into the backlog). If a run failed: „Erneut versuchen“ (try again) with „Was soll anders sein?“ (what should be different?).

Why work with Markdown artifacts?

Files like PROJECT.md or INSTRUCTIONS.md are human-readable, versionable and friendly to AI tools. They form the „working contract“ between user, platform and agent. The agent reads them as a top-level brief, you can edit them and trace changes in Git history. Unlike binary configurations or DB columns, Markdown is also useful outside our platform — you never get locked into a proprietary format.

Is the platform a real multi-agent system?

Not in the sense of „multiple agents talking to each other“. A run has exactly one executing adapter; the model is chosen per role (plan → Architect, build → Developer), and the quality gate checks with its own reviewers. Since v0.21 there is a workflow layer on top: a piece of work is split into tasks that run in parallel as child runs — at most three at a time per workflow, each in its own git worktree, switched off by default via feature flag. Details under Known Limitations.

How do I start the platform?

In the unpacked starter package:

cp .env.example .env     # set the admin password
./start.sh               # Windows: .\start.ps1

The script checks the requirements, starts Postgres in a container and then the factory; then open http://localhost:8080. Details in the quickstart.

Which Java version?

Java 25 (LTS). Spring Boot 4.1.1. If you run the JAR directly you need a matching JDK.

What about Postgres?

PostgreSQL 18 as the single-tenant DB (pinned to postgres:18.6-alpine in docker-compose.yml). Schema migrations via Flyway, currently up to V82. In the test profile H2 runs with Postgres compatibility mode.

Does the platform work offline?

The factory verifies its license offline; it only needs the license server to renew the lease. If the server is unreachable, the existing lease stays valid, then a grace period applies and, on request, a short emergency grace; once that has expired too, no new run with a real AI agent starts; runs with the mock remain possible (merging and pull requests, however, require a valid license). How long each lasts depends on tier and delivery form — the values are under Pricing. Enterprise Air-Gap works with no network at all: renewal once a year via a signed certificate file (USB stick or controlled file transfer).

Can it be run air-gapped?

Yes, with an Enterprise Air-Gap license. The platform itself has no hard internet dependency. What you need:

• A fully offline-verifiable license certificate (Ed25519-signed, renewed yearly).
• Annual renewal via USB stick or file transfer.
• The LLM must be on-prem (e.g. Ollama with Qwen 3 Coder, DeepSeek V3.2). Vendor cloud adapters aren't possible in air-gap mode.
• Version cache must be seeded in internet mode — alternatively the code-level fallback versions kick in.
• Switch off tool installation (softwarefabrik.werkzeuge.installation-erlaubt=false) and provide the toolchains in advance — otherwise the factory downloads them from the internet.

How many templates exist?

19 — five backends (spring-boot-backend, quarkus-backend, dotnet-backend, python-fastapi, node-express), 13 frontends (static-frontend, frontend-react, frontend-angular, frontend-vue, frontend-thymeleaf, frontend-vaadin, frontend-blazor, frontend-flutter, frontend-react-native, frontend-maui, frontend-wpf, frontend-monogame, frontend-javafx) and existing-repo-import for existing repositories.

Which templates exist in detail?

Snippets and base prompts sit on the classpath under resources/wizard/snippets/<lang>/ and resources/wizard/prompts/<lang>/ and exist in DE and EN (you choose the language in wizard step 4).

What happens in the last step of the wizard?

Summary with objective preview (collapsible, shows the final initial prompt for the agent) and cost estimate (local via JTokkit, no LLM call, default model claude-sonnet-5-5).

How do I create a project without the wizard?

„Neues Projekt“ (new project) on the dashboard and project list opens the quick start: three inputs (name, kind, description) instead of six steps, then „Bauen“ (build). In expert view „Nur Projekt anlegen“ (only create project) creates the project without starting a run. If you want to fill everything yourself, use „Leeres Projekt (Experten)“ (empty project for experts; up to 0.46 „Schnell anlegen“) in the project list: a two-field form (project title, product name), then you go straight to the editor. The „Ausführlicher Assistent“ (detailed wizard) sits next to it if you want to set stack and checking tools step by step.

There is nothing to switch off; no setting removes the wizard from the interface. The „Einfach | Experte“ (simple | expert) switch in the header (from 0.47) only controls how many options the interface shows; what you may do is decided by your role alone.

Which adapters are there?

Which default models does the platform use per role?

Each agent role has a default model (ModelCatalog):

• Architect & Documentation: claude-opus-5-5 — for deep design and documentation decisions.
• Developer, QA & Merge/Release: claude-sonnet-5-5 — balanced for implementation.
• Reviewer & Security Reviewer: claude-haiku-5-5 — fast and cheap for read-only checks.

Only the Architect default (plan and spec runs) and the Developer default (build runs) are used automatically, and only with the Claude adapter; the others are suggestions for a role's preferred model. A routing override in settings (run.routing.plan-model, run.routing.build-model, run.routing.spec-model) and the team's preferred model take precedence. Aider and Kimi take their default model from configuration (softwarefabrik.execution.aider.model or …kimi.model); Codex and Gemini currently leave the choice to their CLI.

How does per-role model routing work?

Every AgentDefinition has a nullable preferredModel field (V14). The Claude Code adapter appends it as a --model flag. IDs not in the pricing table fall back to the CLI default, with a note in the run log. Which model came from which source is recorded by the RUN_MODELL_AUFGELOEST attestation.

Can I pick a different adapter per run?

Yes. In expert view the „Neuer Lauf“ (new run) form has the choice „KI-Werkzeug (Adapter)“ (AI tool); in simple view the factory uses the configured adapter. If you pick something there, it overrides the global default (override order: RUN > PROJECT > USER > GLOBAL > YAML). Useful for A/B comparisons: same brief, once with Claude, once with Codex, then compare results.

What does the quality gate do?

The quality gate is an automatic assessment of the run output. It calls multiple reviewers, collects their findings and produces an aggregated verdict (PASSED / WARNING / FAILED / SKIPPED / ERROR). Reviewers are read-only — they don't write into the workspace, they only inspect.

Which stacks does the build gate build and test?

The build gate runs before the quality gate and builds according to the detected project profile. Level A (checked): Maven and .NET. Level B (usable): Gradle, Python (pip, uv, Poetry), Node.js (npm, pnpm, Yarn), Go, Rust and CMake. For other builds you enter a build command on the project page.

If a tool is missing or no build or test step checked anything, the result is “not checked” instead of red — and never passed: the run then needs an approval before the merge. Under “Build-Container” you set the image, CPUs, memory and time limit per project; an ADMIN installs missing toolchains under “Einrichtung → Werkzeuge”. Details in the user manual, section 5.5.

Which reviewers are built in?

• aider-review — invokes the Aider CLI in read-only mode, looks for code smells and improvements.
• claude-review — invokes Claude Code in read-only mode and has the model critique its own output.
• security-reviewer — static heuristic engine: scans for hardcoded passwords, weak crypto, SQL injection patterns, missing input validation, …
• architecture-reviewer — static path heuristics: layer violations in Java/Kotlin packages (e.g. JPA in the domain), changes to existing Flyway migrations and checked-in .env files. Without Java/Kotlin in the diff it says that its layering rules do not apply.
• hallucination-reviewer — looks for invented method calls, non-existent packages, or made-up API signatures — and checks claims about the code (e.g. “all tests pass” without any test change). It checks new imports against the manifest (package.json, requirements.txt/pyproject.toml, *.csproj, go.mod, Cargo.toml); a package missing there is reported as a hint.
• dependency-scan — Trivy-based dependency and licence scan. CVE findings in the SECURITY category block the merge.
• spec-conformance — only for runs with a spec: rule-based check that every bound acceptance criterion is referenced in a test (a heuristic, see Known Limitations).

What do the verdicts mean?

• PASSED — no findings, all reviewers green.
• WARNING — some findings below the blocking threshold.
• FAILED — at least one blocking finding (by policy or special rule).
• SKIPPED — all reviewers were skipped (e.g. no reviewer CLI is installed or there was nothing to check).
• ERROR — a reviewer aborted with an error (e.g. a timeout), or under strict a mandatory review is missing. A reviewer CLI that is not installed counts as skipped, not as an error. Deliberately not swallowed.

Each reviewer returns findings with category and severity (LOW/MEDIUM/HIGH/CRITICAL) plus a confidence score (0..1) for its overall result; the verdict is aggregated from these.

What are the special rules?

Two finding types are always blocking, regardless of policy:

• SECURITY/HIGH — e.g. hardcoded secrets in committed code, weak crypto algorithms, obvious SQL injection.
• ARCHITECTURE/CRITICAL — e.g. a domain class importing Spring, web layer reaching directly into infrastructure.

This rule prevents an overly relaxed policy from quietly waving through critical issues.

What's the difference between strict and lenient policy?

• lenient (default): only CRITICAL findings block, no mandatory reviewers, no confidence floor. Good for first runs and experimental projects.
• strict: HIGH findings block as well, security and architecture reviews are mandatory (if missing, the gate ends in ERROR), and if the aggregated confidence score is below 0.7 the result is at least a warning (WARNING). Good for production setups.

Special rules (SECURITY/HIGH, ARCHITECTURE/CRITICAL) are blocking either way.

What can I configure in the settings area?

Under /einstellungen (Einrichtung → Einstellungen, ADMIN-only) you can configure:

• AI access: subscription or API key and sign-in directory per agent, as one table.
• Operating mode: single seat (subscription) or team (API pool).
• Workspace: default root path for run workspaces.
• Git: user name and email for auto-commits.
• Adapter: default adapter and default model per adapter.
• Wizard: version cache overview and manual refresh.
• Feature switches: state and environment variable (workflows, specifications, PR feedback, licence check, signed audit chain) — read-only, because they take effect at start-up.

Models, control artefacts, costs and runs are collapsed under „Erweitert“ (advanced). Since 0.49 you set quality-gate mode and strictness, sandbox and approval on the Leitplanken (guardrails) page (/leitplanken) — in three levels (Vorsichtig, Ausgewogen, Schnell) or individually in expert view. Import folders and Git hosts are under Einrichtung → Import-Ordner und Git-Hosts.

How does the budget work?

Effective budgets are in euros per calendar month, not in tokens. The platform computes each run's cost from token usage and the pricing table.

• Project budget: monthly budget per project with a warning threshold (default 80 %). Optionally enforced: from 100 % the creation of new runs is blocked.
• Tenant budget: monthly budget across all projects of a tenant, optionally as a hard cap.

Running runs are not aborted — they finish.

When do settings changes take effect?

Immediately: on save, SettingService evicts the affected cache entry. The 5-minute TTL cache only bounds how long a value changed by other means (e.g. directly in the database) can stay stale. No restart is needed.

Who can change settings?

Only users with the ADMIN role. Primarily the bootstrap admin (SOFTWAREFABRIK_ADMIN_USER); you can create more admins under /admin/nutzer. Every change creates an audit log entry with subject (who), scope, key and timestamp; the values themselves are not logged.

How does the platform handle security and privacy?

The platform aims for data-minimal, traceable use:

• No secrets in source, no plaintext password in logs.
• API keys AES-GCM-encrypted in Postgres (master key from env var).
• Passwords BCrypt-hashed (default cost factor 10).
• Audit log for all security-relevant events.
• Approval policies before critical phases.
• docker-compose Postgres mapping pinned to 127.0.0.1 — not accidentally exposed.
• pgJDBC 42.7.14 (fixes CVE-2026-42198 and CVE-2026-54291, among others).

How is the agent isolated?

Two modes: The agent runs as a process next to the platform: filtered env vars, an ephemeral HOME holding only the adapter's credentials, workspace as working directory. On top, ContainerProcessSandbox (setting execution.sandbox.variant=container) encapsulates build and scans of the generated project in an ephemeral Docker or Podman container with --cpus 2 --memory 4g --pids-limit 512 --read-only (CPUs and memory as the default, adjustable per project under “Build-Container” up to the operator's limits); network stays allowed there (Maven dependencies, trivy database).

Where are API keys stored?

In Postgres, encrypted with AES-GCM. Master key from SOFTWAREFABRIK_SECRETS_MASTER_KEY (at least 32 characters). Without the master key the platform refuses to start — only the local development profile uses an insecure fallback key. Audit log records every key change.

How is a user authenticated?

In v1: local authentication with username + password against the platform DB. BCrypt-hashed passwords, CSRF protection, HttpOnly session cookie with SameSite=Lax; behind HTTPS you switch on the Secure flag with SOFTWAREFABRIK_COOKIE_SECURE=true (from 0.41.5). Optionally the platform delegates login via OpenID Connect to a corporate IdP (Keycloak, Entra ID, Okta, …); new SSO users are created as VIEWER without a tenant.

What goes into the audit log?

• User management (creation, role, tenant, lock, password reset, SSO provisioning). Login attempts themselves are not logged.
• Settings changes (scope, key, subject, timestamp — without values).
• Run starts (run ID, adapter, model, subject).
• Approval decisions (phase, decision, subject).
• Adapter configuration changes (integration setup with encrypted API key).

Append-only as a hash chain, with each entry Ed25519-signed when attestation is enabled; the chain check detects tampering. Table audit_event.

Is the platform suitable for regulated environments?

It's well aligned — traceability, structure, documentation, Git discipline and explicit approvals are built in. Concrete hardening (e.g. ISO-27001, BAIT, DORA conformance) depends on the deployment environment and needs additional organisational measures. Technically, the compliance profiles (EU AI Act, BAIT/MaRisk/DORA, BSI/VS-NfD) as signed policy-as-code, the signed audit chain and the audit export help. For government we recommend the air-gap tier with on-prem LLM.

Which license tiers exist?

Three tiers — Community, Professional and Enterprise:

• Community (free, no account, just an e-mail address): for a single seat; tenants, roles, SSO and audit chain included. Requested directly in the factory under Einrichtung → Lizenz.
• Professional (€20–30/month per user): higher limits, spec-driven development, priority support.
• Enterprise (from €20,000/year): contracted limits, SDD governance, Cloud/Self-Hosted/Air-Gap, priority support.

All limits and lease durations: Pricing. What of it is enforced today is described there and under Known limitations. The public demo instance needs no license — “demo” is not a tier.

How does the license work technically?

EdDSA/Ed25519-signed JWT lease tokens from the license service. The platform verifies offline against the bundled public key (also published at https://license.softwarefabrik.io/api/v1/pubkey). Tier features are coded in the lease claim. Setup & trust chain in the transparency document.

Which LLMs are supported?

• Anthropic Claude (official API; the cloud gateways AWS Bedrock and Google Vertex AI are experimental — implemented but not yet live end-to-end tested; production use only after customer-side verification).
• OpenAI (official API; Azure OpenAI is experimental — implemented but not yet live end-to-end tested; production use only after customer-side verification).
• Google Gemini (Vertex AI is experimental — implemented but not yet live end-to-end tested; production use only after customer-side verification).
• Moonshot Kimi (Kimi CLI, API key or subscription).
• On-prem via Ollama or vLLM: Qwen 3 Coder, DeepSeek V3.2, GLM-5.1, others.

LLM choice is the customer's call and configured in the adapter. Air-gap mode allows on-prem LLMs only. A consolidated list of open items is available under Known Limitations.

Can I switch between tiers?

• Community → Professional: any time by importing the Professional license file (Einrichtung → Lizenz, i.e. setup → licence).
• Professional → Enterprise: via contact, individual migration including contractual alignment.
• Enterprise deployment switch (e.g. cloud → self-hosted): part of the contract, applied with a new license file.

How does it differ from LangChain / LangGraph / AutoGPT?

LangChain and LangGraph are library frameworks for Python developers building AI workflows themselves. AutoGPT is an experimental auto-run agent that decomposes tasks largely autonomously. The Software Factory is not a library — it's a finished web application with a defined workflow (project → artifacts → run → quality gate). You don't program it, you use it. The audience is therefore much broader: not only Python devs with an AI background, but every lead developer.

When does multi-agent execution arrive?

Partly already there: plan, build and spec runs get their own model per kind of run (capability routing: plan and spec use the Architect's model, build the Developer's), reviews run with dedicated reviewers, and since v0.21 the workflow layer distributes a piece of work across parallel child runs (feature flag, at most three at a time, single host only). Agents that communicate directly with each other do not exist.

Is there a roadmap?

Yes, in the distribution at docs/roadmap/reifegrad-roadmap.md. Tenant separation (own policy, audit view, costs and export per tenant) has shipped since v0.17; a plugin API is not planned, and an SPA frontend is deliberately ruled out. The news page keeps the current status, and the Known Limitations page collects open constraints.

Is there deeper technical background available?

Yes. As an architecture deep-dive there's a separate whitepaper covering the architectural foundations of agentic software development: reference architecture, agent orchestration, AI guardrails, shared knowledge stores and integration into the SDLC. The PDF is free and downloadable without registration.

How does the wizard work internally?

There are two paths under /wizard. The quick start (/wizard/schnellstart, target of „Neues Projekt“) asks only for name, kind and description, fills in the rest with defaults; „Bauen“ (build) creates the project and starts the first run right away, with the description as the task. Its second tab imports an existing project (folder or Git address) and likewise starts the first run. The „Ausführlicher Assistent“ (detailed wizard) is a six-step controller with its own persistence in wizard_draft (V12). Steps:

1. Target platform: web, mobile or desktop. The choice determines which backends and frontends can be combined at all.
2. Backend: Spring Boot, Quarkus, .NET, FastAPI, Express — or importing an existing repository.
3. Frontend(s): one or several frontends (React, Angular, Vue, Thymeleaf, Vaadin, Blazor, Flutter, React Native, MAUI, WPF, MonoGame, JavaFX, static).
4. Questions: a dedicated set per template (Java version, DB, architecture style, Node version, build tool, …). Answers are stored in a JSON column.
5. Quality-gate toggles: e.g. ArchUnit, OWASP Dependency-Check, Trivy, Playwright, ESLint, Vitest, Ruff, mypy, Bandit or Roslyn analyzers. Which ones appear depends on the chosen stack — ArchUnit only for Java backends, for instance.
6. Summary: overview of all answers with cost estimate and prompt preview, then „Projekt anlegen und bearbeiten“ (create and edit project). The wizard creates a ProjectDefinition, fills all editor fields and marks the draft completed.

Drafts survive browser reload and server restart. The next visit to /wizard shows a „Resume draft“ button that takes you to the last saved step. Unfinished drafts are auto-deleted after 30 days (cleanup job at 04:00).

Why Spring Boot + Thymeleaf instead of Angular/React?

Version 1 prioritises orchestration, run model, Git/build integration and traceability. A server-rendered UI with Spring Boot and Thymeleaf reduces complexity — no separate frontend build, no API versioning, no double authentication. That makes the product core trustworthy faster. A SPA is deliberately not planned (maturity roadmap: “no SPA”).

How do version values reach the wizard?

From the version_cache (V13). A daily @Scheduled job at 03:00 fetches current stable versions from three sources:

• Maven Central for Spring Boot, ArchUnit, OWASP Dependency-Check.
• GitHub Releases for the Trivy CLI.
• npm registry for Playwright.

Cache keys are functional, not technical: spring-boot.3.x, archunit.latest, trivy.cli.latest, … If the cache is empty or stale, the wizard falls back to hard-coded versions from the source.

What happens if the version cache is stale?

„Stale“ means: Java-computed, the last refresh is more than 25 hours old. The wizard still shows the values (with a stale badge in the admin UI), and you can hit „Jetzt manuell refreshen“ (refresh now) at /einstellungen/wizard/versions to trigger a synchronous lookup. If the lookup job has failed multiple times, the last error is shown in the last_error column.

Can templates be extended?

In code: a new entry in TemplateRegistry (immutable record with fields and supported toggle IDs) plus snippets under resources/wizard/snippets/<lang>/<toggleId>.md and base prompt under resources/wizard/prompts/<lang>/<templateId>/basis.md. 19 templates are registered today. UI-based template management (custom templates via drag-and-drop) stays a V2 topic.

What is the override order?

PROJECT > USER > GLOBAL > YAML. A project-level value beats a user-level value beats a global value beats the default in application.yml. SettingService implements this resolution uniformly for all settings.

Can external plugins / adapters be loaded?

In v1: no. Adapters are added as Java classes in the codebase. A plugin API (e.g. via Java Service Provider Interface or Spring Boot Starter mechanism) is not currently planned, because a stable plugin API design is only worth it once the adapter logic has iterated a few times.