The dim factory for software consultancies

Our bet: 2–3× the projects. Same senior bench.

Machines run cold — agents build to frozen scope under mercury light. Humans run warm — your seniors approve the moments that matter. Decisions are white — every one on the record.

Book a pilot call or walk the line below — 3 stops, 3 clicks, you play the human
Built for fixed-bid consultancies 10–100 seats Every approval recorded Regulated & public-sector friendly Pre-MVP — in build with its design partners
dim factory
/dɪm ˈfæk·tri/ · noun

A software delivery line lit by two lamps. Machines work under mercury — cold, tireless, mostly automated. Humans work under sodium — warm, deliberate, minimally staffed. Where the lights cross, a decision is made — and it goes on the record in white.

The problem

Your revenue is capped by headcount

Declined RFPs

Seniors are fully allocated, so bids go unanswered and start dates slip. Every pass is revenue that never existed.

Rework on fixed bids

Scope that was never truly validated comes back as rework — and on fixed-bid work, rework is paid out of your margin.

Point tools, no throughput

Coding assistants speed up individuals. Nothing connects sign-off → build → review → handoff at the firm level.

Stop 01 · Win · ships post-MVP

Halflight Bid

RFP & estimation

An RFP lands. Bid reads it, extracts the requirements, and drafts a line-item estimate banded against similar past projects — in minutes, not the week your seniors don't have.

You check the numbers and send. That's the whole job.

Your move on the right: one click to send the proposal. →

bid · station 01 worked example

incoming — rfp-2026-014.pdf

client portal + authcase intake workflowreporting & exportsadmin console

estimate — draft

fixed-bid total$0
Illustrative figures. The ±12% band comes from the estimating model, not from delivered projects — we don't have those yet.
PROPOSAL SENT
machines reading the rfp…
Stop 02 · Validate

Halflight Blueprint

Client design validation

Blueprint turns the brief into working mockups your client clicks through at a live preview link, then runs the review loop for you: comments in, revisions out, every change versioned.

When the client is happy, one click freezes scope. From that moment, changes are new billable work — not absorbed rework.

Agentic pipelines fail on ambiguous requirements. Blueprint manufactures unambiguous ones.

← Your move: freeze the scope when the client approves.

blueprint · station 02 worked example
    in review with the client…
    Stop 03 · Deliver

    Halflight Assembly

    AI-guided delivery

    Assembly decomposes the frozen package into a task graph and builds. Tests run continuously; previews stay client-visible. Your seniors see exactly one thing: the decisions that need a human.

    No merge happens without a named engineer's approval — and every approval lands in an audit trail your regulated and public-sector clients can inspect.

    Your move on the right: review the diff, approve the merge. →

    assembly · station 03 worked example
    tasks 0/24 · tests passing
    PR #112 — auth flow+214 −38
    // session guard- if (user.role == "admin")+ if (session.can("cases:write"))+ audit.record(session, "merge")
    MERGED · approved by you · recorded to audit trail
      machines building from the frozen package…
      The arithmetic

      Where the 2–3× comes from

      A senior engineer spends about two days building a feature — or about 25 minutes reviewing the factory's PR for it, because the scope was frozen and the tests already ran.

      Spread that across a bench, and each senior can carry several projects at once instead of one. That's the multiple.

      These are estimates, not measurements. We haven't run this at scale yet — no delivered projects, no benchmark, nothing to point at. The pilot exists precisely to test the number on your projects instead of our worked example. If it turns out lower, you'll hear it from us first.

      run receipt — worked example
      tasks completed24
      tests run117 · passing
      human decisions3
      senior time spent~32 min
      client visibilitypreview + sign-off
      the old way~3 senior-weeks
      Modelled, not measured — the figures a run like this is built to produce. Walk all three stops above and this receipt is yours.
      Deliberate constraints

      What we won't promise you

      • No autonomous merges. Ever. A named senior engineer approves every merge, or it doesn't ship.
      • One opinionated stack at launch. Depth before breadth — the factory does one thing excellently before it does five things adequately.
      • No "replace your engineers" pitch. Halflight is capacity expansion for your senior bench, not a substitute for it.
      • Bid ships after the MVP. We'd rather nail Validate → Deliver with design partners first than launch three half-built modules.
      Objections, welcome

      The questions owners actually ask

      Who owns the code?
      You and your client, exactly as today. The factory commits into your repositories under your agreements; full IP assignment, no license-back, nothing of yours trains anything of ours.
      What happens when the AI writes garbage?
      It doesn't merge. Tests and static analysis run on every change, and a named senior approves every PR — garbage gets rejected at review like any junior's would, except it cost minutes instead of days. Pilot projects are deliberately well-bounded so the failure modes are cheap to catch.
      What if this doesn't work out mid-project?
      You're never stranded. Everything lives in your repositories from day one, and nothing merged without your senior's approval — so your team can take over any morning without asking our permission. If the pilot ends early, you keep it all: code, designs, audit trail. The handover is already done, because nothing ever left your house.
      How does this pass a client security review?
      Your seniors set the guardrails — stack, patterns, security baseline — before any agent runs. Deployment targets your cloud, and every human approval is in an audit trail your client (or their regulator) can inspect. That trail exists because our own background is public-sector delivery, where it's non-negotiable. The whole position is written down to be forwarded: read the security & data brief.
      What stack does it build in?
      One opinionated stack at launch — modern TypeScript end-to-end (React, Node, Postgres) — because a constrained factory ships reliable software and a flexible one ships demos. Additional stacks come after the first one has paying customers.
      What does the pilot cost?
      Nothing for three months — and we agree the post-pilot price in writing before we start, so free never becomes a negotiation lever. The pilot ends at a fixed date: continue at the agreed price, or walk away with everything the factory built for you.
      Founders

      Built by the engineers who'd have to approve the merge

      The hard part of an agentic delivery line isn't the agents. It's everything that has to hold around them, and that's the half we've spent our careers on.

      What has to hold
      • pipeline & release CI/CD gates · static analysis · dependency scanning · signed artifacts
      • runtime Kubernetes · Helm · containers · per-branch preview environments
      • isolation Terraform · network boundaries · secrets management
      • services & APIs microservice boundaries · queues · versioned contracts
      • data & signals Postgres · migrations · restore drills · traces · alerting

      Halflight is a new company, built in the open with its first design partners. Both of us are on every working session.

      See what a design partner gets →
      The design-partner pilot

      Free while we build it. Priced before we start.

      We're taking three design partners — fixed-bid firms who want the factory shaped around how they actually deliver. It's in build right now, which is the deal: your feedback is the backlog, and the early risk is why the price is agreed before you start.

      1. Pick one or two well-bounded projects

        Modest scope, real client, real stakes — the kind you'd staff two seniors on today.

      2. Month one: your seniors set the guardrails

        Stack, patterns, security baseline — before any agent runs. Then one bounded task walks the line and the first PR lands on your review console.

      3. We build the MVP against them

        Free for three months. Weekly working sessions — your feedback is the product backlog.

      4. Your team runs Blueprint → Assembly

        Your engineers on the review console, your client in the validation loop, us alongside.

      5. Convert on pre-agreed terms

        The pilot ends at a fixed date. Continue at the price we set up front — or walk away.

      What we ask of a design partner

      • Real projects, not sandboxes
      • An hour a week of working-session time
      • Honest feedback — your needs set our roadmap
      • A case study and reference, if we earn it
      Book a pilot call

      30 minutes. Bring one project — we'll walk it through the line, stop by stop, and you'll leave knowing what month one looks like.

      Halflight Labs

      The lamps are on.
      Walk the line, then run it on a real project.

      Founder-led and bootstrapped — you'll work directly with the people building it.

      Book a pilot call — your decision, in white