Frequently asked questions

It automates the system around the code. Coding tools make writing code faster; you still scope, connect, verify, and get it live. lumaq runs that whole system — requirements, blueprints, work orders, verification, a single approval, and feedback as one connected loop — and delivers software you can trust and own, without staffing for it.

Yours. lumaq ships the control plane and the worker, not the intelligence. Connect your own coding agent (Claude Code, Cursor, Devin) over MCP, or run the lumaq worker on your machines, on a model you choose — a hosted model on your key, or an open-weight model inside your network. We never train on your content.

There is a single required approval. Agents do the volume but they only propose; the change is accepted against the spec, and a named approver — never the person who did the work — closes it. No scoring, no stack of gates, nothing that silently blocks a merge. One deliberate approval, on the record.

No. An agent can move a work order as far as review and no further, on any channel — web app, API, or MCP. The rule lives in the domain, not the interface, so it holds no matter which tool is driving the agent. Agentic, not autonomous.

Yes — that is the case it is built for. The platform rebuilds around what has to keep running, reconstructing the logic buried in the legacy into a living specification you can read and trust, so you replace the black box without freezing the business to do it.

The agent reads the existing codebase and proposes the requirements it actually implements. Every recovered rule links back to the code it came from and forward to the blueprint that replaces it — so what gets rebuilt is provably faithful to what the old system did, not a guess.

Yes. Because work is structured into work orders with their own acceptance tests and dependencies, many systems can move in parallel without stepping on each other — at production quality, without a multi-year freeze.

It is the system's own record, not something written after the fact. On every push, code is compared against the blueprint and the blueprint against the requirement, and drift comes back as a finding. Built-in automations keep it honest on a schedule, so the spec never quietly falls out of date.

One connected graph. Artifacts, requirements, blueprints, work orders, code, and feedback are linked both ways — so the chain from a piece of user feedback, through the requirement and the work order, to the exact commit that answered it is a single query.

Your own systems post it in through a write-only API — no account needed for the people reporting it. It is grouped into themes with the quotes as evidence, and a theme becomes the next requirement or revision work order. The loop closes back to the spec.

In your environment. It is deployed on your premises and shipped as a single image for locked-down or air-gapped installs. On the private path, code and documents are indexed on your own machines and never leave your network — and where the requirement is absolute, the model runs inside it too.

No. Your content is never used to train anything. That holds whether you run a hosted model on your own key or an open-weight model inside your network.

No. Every change is stamped server-side with its origin — user, agent, automation, API, or MCP — so authorship can't be claimed, only recorded. The trail is append-only, tamper-evident, verifiable on demand, and exportable.

Disconnect a repository and its index is deleted with it. Archiving a project is reversible; permanent deletion is a separate, approved action. Nothing lingers quietly, and nothing is purged by accident.

lumaq is built to the enterprise security frameworks relevant to your industry, with the audit trail and data controls above. Specific certifications and documentation are shared under NDA as part of a scoping engagement.

Model policy is set once, at the org level: allow or block a whole provider — future models included — or single models. Nobody has to pick the right one; the default is automatic, inside your allowlist.

Usage is broken down by project, user, model, and agent, with budgets and threshold warnings — and a hard limit that stops new agent work rather than surprising you at month end.

You own the code, the IP, and the audit trail from the first commit. No proprietary runtime, no lock-in — a standard, exportable stack you can take in-house or to any vendor, any time.

Three steps: scope is discovered and locked, the platform delivers while you approve at the review gate, then handover with the spec and audit trail intact. Pricing is per engagement, enterprise and custom — not a per-seat subscription. Book a scoping call for a costed plan.

At this stage it is enterprise-only and done-for-you — the platform runs the delivery and ships the software; you approve at the gate and own the output. You can step through the pipeline on this site to see how it builds, and see the product live on a call; there is no self-serve access yet.

We're early and direct about it: no customer logos to show yet. What we can show is the working product — a walkthrough of the pipeline on this site, and a live demo on request — and we're taking on our first enterprise engagements. Real results replace the demo as pilots ship.