The hard questions, answered honestly.

No. Copilot, Cursor and similar tools are coding assistants: they speed up typing in the editor. beacon is an AI-native Operating Model that carries the whole software-engineering lifecycle, from idea through spec, build and test to operations. Humans and AI agents work a shared board; every task is traceable (who, what, when, on which spec, with which model), cost-attributable, and runs through the same guardrails and quality gates. The difference isn't the language model, it's the system around the agents: identity, memory, a task model, traceability, built-in quality, and a closed loop into production.

You own the whole beacon: source code, tests, documentation and infrastructure definition, with no runtime dependency on our platform. The beacon platform is the workbench work is built on, not the runtime your system runs on. The result is ordinary, readable, standard code (TypeScript, NestJS, React, Postgres) on standard infrastructure that your team can maintain without us, without our agents, and without our license. No vendor lock-in, no process lock-in: the beacon is yours, and you can license the workbench separately if you want to build yourself.

Honest answer: measured, not guessed, but not yet attested by an external audit. The number comes from real throughput on a shared board: lead and cycle time, flow efficiency and throughput, from which a probabilistic Monte-Carlo forecast (p50/p85/p95) is built, instead of story-point guesses. Spec work, challenge and human review are in the denominator; we don't hide the human time. A co-founder has externally sanity-checked the order of magnitude; an independent third-party audit and named client references are the next step. The most transparent proof is our own build: the beacon platform builds itself, disclosed end to end.

Human in the Loop is a principle, not a headcount limit: a human owns the decision at the OK Point, decides before the merge and stands behind the outcome, while the AI agents deliver the volume underneath. Today we're a small team with one accountable human at that gate, but that isn't a permanent ceiling, it scales: whoever licenses the beacon platform decides how many people work on it, in roles like contributor, reviewer or viewer. And what matters for your risk: your beacon is handover-ready standard code that you run yourself, so your production system doesn't depend on our availability.

Yes, because quality is built in rather than bolted on at the end. We work spec-first and red-first: the spec is the source of truth, a second agent challenges it adversarially and finds the gap, and the tests are written before the code. That is Spec Test-Driven Development (STDD) in its purest form, and STDD together with deterministic guardrails (domain invariants, a Definition of Done, lint, types, CI) is what truly sets our approach apart. The result is readable, conventional code your team can read, refactor and extend without us, not multi-agent spaghetti. And your product's documentation is always current, because it's maintained during development: living domain docs where code and documentation never drift apart.

A human, always, and it's provable to the line. Every agent is assigned to a human contributor or reviewer, and every action in the repository is tagged with both, the user and the agent. No agent merges to production autonomously: two OK Points frame every piece of work, and a human integrator is the only one who merges and carries the accountability. The names are roles, not a way to blur responsibility; "Paula approved it" means "the assigned human said yes at the gate." So at any point it's clear who is responsible for which change.

That's exactly where the process bites, instead of papering over the gap. After the first spec, a second agent attacks it adversarially (challenge-spec) and surfaces ambiguities, missing acceptance criteria and edge cases; then a human decides at the OK Point. Where a problem can't be specified cleanly, the human does the hard 20 percent and the agents do the well-bounded rest; we don't promise an autopilot. Control at the moments that matter, guardrails for everything else.

You decide, not us. Run beacon on-premise or Swiss-hosted, and your code, repositories, memory and audit trail stay at rest inside your perimeter; the only thing that leaves is the model call, to exactly the provider you chose, on your keys and under your contract including the data-processing agreement (DPA). You set the allowed model roster and can exclude providers, for example to keep EU or Swiss data residency and GDPR, DSG or FINMA compliance. Every model call is a visible, deliberate trade-off, never a hidden default. Formal artifacts like certifications (SOC 2, ISO 27001), DPA templates and sub-processor lists are something we're building out, so please ask.

Because every unit of work is a task on a known-priced model, cost is attributable: broken down per task, session, workflow and model, with the option to swap a premium model for a cheaper one where it's enough. You see what each piece of work and each model actually cost, instead of a lump-sum bill at month-end. Honestly: hard project budgets and caps that stop you before you overspend are still on the roadmap; today the lever is model choice, not an automatic cap.

That's exactly the challenge we're looking for. Our public beacons are deliberately well-bounded new builds, but the real leverage of AI-native software engineering is in what already exists: legacy monoliths, grown codebases, undocumented invariants, brownfield modernization. Our approach first makes the implicit knowledge visible and testable (characterization tests, spec reconstruction from the running system), then takes small, safeguarded steps: refactor and extend, every step checked against domain invariants, with an audit trail and a human OK Point. If you have a hard legacy or migration case you think is "impossible with AI," that's precisely the one we want to talk through with you and prove it can be done. Bring us your hardest system.

With exactly one well-bounded step: the beacon. A beacon is a productive system, running in production, that we build for you, documented and handover-ready, not a big-bang program and not a months-long proof of concept with nothing to show. It makes visible, on your real work, what AI-native engineering delivers under real conditions, and it's the validated reference for every decision that follows. The way in is a conversation, no commitment. Access today runs through early access by invitation, leave your email for the waitlist.

Not yet. The platform is in active development and currently available by invitation only (early access), deliberately, so quality, security and operations stay clean while we build. Leave your email for the waitlist and we onboard in waves.

Pricing isn't final yet. We deliberately set it after the early-access program and publish it openly then, shaped by real usage rather than a whiteboard. A preview: transparent and usage-based, with a fair cap, no lock-in, and the AI model costs run on your own keys (BYOK). Everyone in early access helps shape the pricing and sees the numbers first.