Black Box Factory

A factory for consequential software.

Black Box Factory is Naevum's custom AI delivery service for leaders with one operating problem, so that a separate reviewer checks the system before their team runs it.

  • Foundation
  • Custom AI
  • Accountable delivery
  • Independent review
Construction and independent challenge. An illustrative development process from bounded brief through candidate review and handover.
Loading model
Technical descriptionsInteractive model unavailable. The static illustration and descriptions remain available.
Brief and architecture
Turn the desired workflow into responsibilities, interfaces and inspectable acceptance conditions.
Technical data

Inputs

User workflow, constraints and desired outcome.

Transformation

Turn the desired workflow into responsibilities, interfaces and inspectable acceptance conditions.

Retained state and outputs

Objective, scope, ceiling, expiry and confirmed plan revision.

Task interfaces and acceptance basis.

Constraints

The confirmed scope, acceptance basis and execution ceiling constrain the work.

Attempt and resource scheduler
Bind one eligible attempt to its source and finite capacity.
Technical data

Inputs

Confirmation bound to the exact proposed mandate.

Identified task and source/acceptance basis.

Accounting reservation retaining review capacity.

Retained task and next decision after uncertainty is resolved.

Transformation

Bind one eligible attempt to its source and finite capacity.

Retained state and outputs

Attempt, project, base and policy identity.

Separate implementation and challenge capacity; reservation is not permission.

Constraints

Capacity reservation and permission are separate prerequisites.

Implementation bench
Transform the task into an artifact and correct identified defects.
Technical data

Inputs

One admitted bounded implementation attempt.

Source-bound unresolved finding; correction creates a new candidate.

Transformation

Transform the task into an artifact and correct identified defects.

Retained state and outputs

Exact source candidate and artifact.

Each correction produces a new candidate identity.

Constraints

A correction creates an identifiable new candidate for examination.

Independent challenge
Review and QA examine the same candidate through separate responsibilities.
Technical data

Inputs

Exact candidate and artifact for independent examination.

Transformation

Review and QA examine the same candidate through separate responsibilities.

Retained state and outputs

Reviewer findings for the candidate.

Executed acceptance cases and required-check evidence.

Constraints

Independent review and QA must address the same source candidate.

Exact-source comparator
Join candidate, current base, policy, checks and independent verdicts.
Technical data

Inputs

Separate verdict and required-check records for one candidate.

Current integration base and project policy.

Transformation

Join candidate, current base, policy, checks and independent verdicts.

Retained state and outputs

Candidate/base/policy identities.

Missing, failed and stale evidence remain distinct.

Constraints

Missing, failed or stale evidence prevents acceptance.

Handover and continuity
Preserve artifacts, unresolved work and original uncertain attempts for the next operator.
Technical data

Inputs

Observed attempt result or retained uncertainty.

Source/artifact/check packet with remaining delivery decision.

Attributed evidence about the original uncertain attempt.

Transformation

Preserve artifacts, unresolved work and original uncertain attempts for the next operator.

Retained state and outputs

Objective, source, findings and next decision.

Original attempt observations; no replacement while uncertain.

Constraints

An uncertain attempt is reconciled under its original identity before any replacement is considered.

An illustrative development process from bounded brief through candidate review and handover.

Additional mechanisms are described in the technical reference.

An identified build moves from a declared brief through implementation, independent review and QA. Acceptance joins the current source with its evidence; handover retains the result and unresolved work.

From an important problem to a system you can run.

Discuss a system to build

The brief becomes a set of inspectable artifacts.

A useful AI prototype still has to work with the business’s data, interfaces and operating responsibilities. The commissioning team needs a clear path from that brief to software it can examine and run.

Bring Black Box a bounded workflow that crosses those responsibilities. Start with its intended user journey and the conditions that would make the delivered result acceptable; the mandate, architecture and independently examined artifact carry that intent into handover.

  1. The mandate

    Define the work, operating boundaries and outcomes that acceptance must examine.

    Starts with
    A workflow that needs to change.
    Produces
    A bounded system brief and acceptance conditions.
  2. The architecture

    Choose components, data contracts and integration points appropriate to the problem.

    Produces
    A design whose responsibilities can be examined.
  3. The accepted artifact

    Bind the built software, review findings and QA evidence to an exact source and intended environment.

    Produces
    A release and the record supporting its acceptance.

Creation and acceptance have separate responsibilities.

Black Box’s selected factory architecture gives Planner, Coder, Reviewer, QA and service distinct powers.

The Planner translates architectural intent into a proposed mandate. An eligible owner confirms it. Implementation is a bounded attempt; independent review concerns the exact source being judged. The service cannot manufacture the reviewer’s acceptance.

The design reserves capacity for review and QA. It includes acceptance criteria before implementation, checks on the installed artifact and exploratory examination of surfaces that fixed tests do not yet cover.

The selected development direction gives Planner, Coder, Reviewer and QA different identities and bounded attempts. The role-separated triad is an architectural proposal; an admitted project pipeline still needs its own qualification. Reviewer capacity and credentials are reserved as independent resources.

Turn an operating problem into a working system

The CEO decides what counts as accepted; a reviewer who did not build the slice decides whether it meets that. Illustrative.

  1. 1 of 4The CEO states the problem as a responsibility: who reconciles supplier invoices, and what a correct result looks like.Decision: The CEO defines what counts as accepted.
  2. 2 of 4Black Box Factory defines a first working slice and the tests that will judge it, before anyone builds.
  3. 3 of 4A reviewer who did not build the slice tests it against those criteria.
  4. 4 of 4The slice passes and moves to handover with its source, findings and operating notes.
Select any part of the drawingScroll to step · Esc to skipFig. 1
  1. 1 of 4Operations asks for a new approval step after the first slice is live.
  2. 2 of 4The change becomes its own slice, with its own acceptance test.
  3. 3 of 4Review finds that the change touches a payment rule the CEO owns.
  4. 4 of 4The change waits for the CEO, and the hold and its reason are recorded.Decision: The CEO approves or rejects the rule change.
Select any part of the drawingScroll to step · Esc to skipFig. 1
  1. 1 of 4The build team prepares to hand the system to the client's own operators.
  2. 2 of 4The reviewer runs the acceptance tests on the installed system, in its real environment.
  3. 3 of 4One recovery test fails, so the handover returns to the build team with findings.
  4. 4 of 4After the fix passes, the operators receive the source, the findings and the next open decision.Decision: The client's operations lead signs off the handover.
Select any part of the drawingScroll to step · Esc to skipFig. 1

What the research says

A preliminary study finds little return from GenAI

95%1
Organizations reporting zero return from GenAI, in MIT NANDA's preliminary findings

MIT NANDA's preliminary findings, drawn from interviews and conference surveys, say most organizations saw no measurable return from their GenAI pilots. The gap they describe sits between a demo and a system a team can run, so Black Box Factory agrees on acceptance before building and has a separate reviewer test the result.

Inside the mechanism. A useful review changes the candidate.

Illustrative scenario. This is a proposed role-separated delivery trace, not a live autonomous factory demonstration.

The implementation answers the brief but misses a failure case.

An identified source candidate carries the plan and its acceptance conditions into review.

Mandate
Preserve a user’s pending request through interruption.
Coder result
A candidate restores the normal successful path.
Independent challenge
The reviewer finds that an uncertain effect can be duplicated.
QA question
Can the same operation resume without a new external effect?

The next attempt resolves the review finding.

A durable attempt record connects the correction to the original mandate. Delivery remains its own decision.

Correction
Retain operation identity during reconciliation.
Verification
Exercise the interrupted route against the acceptance condition.
Independence
Reviewer and QA use their separate identities and capacity.
Handover
Provide source, artifact and verification evidence to the operator.

Where it changes the work.

Illustrative situations, connected to the mechanisms that make them possible.

Turn architectural direction into delivery

Organizations commissioning custom AI

A difficult brief spans data, software, interfaces and operating responsibilities.

How it works
The Planner defines a mandate; implementation, review and QA preserve its acceptance conditions.
What changes
The customer can examine how the delivered system answers the original brief.

Continue after a worker disappears

Engineering teams

A development attempt ends before the work is resolved.

How it works
The source-bound handover retains objective, checks, findings and the next decision.
What changes
Another attempt can continue from the durable record rather than relying on a departed session.

Preserve independent challenge at scale

Product organizations

Several implementation streams compete for the same finite engineering capacity.

How it works
Separate role principals and reserved review capacity keep judgment in the delivery path.
What changes
Increased implementation activity does not silently consume its own acceptance process.

Delivery includes the next operator.

A working artifact needs a way to be installed, observed, recovered and changed.

Carry the unresolved work

Durable handovers retain source, result, findings and the next decision. Incoming material is treated as evidence rather than new authority.

Make operation concrete

The engagement specifies controls, documentation, recovery and support responsibilities.

Keep the route accurate

Naevum delivers through project-specific build, review and release workflows. The full unattended factory loop is a development direction.

Questions about Black Box Factory.

Do I need the whole Naevum portfolio?

No. The architecture selects the components the problem needs. A bounded integration or a single well-defined product can be the right engagement.

What should I bring to the first conversation?

Describe the work you want to change, its users, current systems, operating constraints and how you would recognize a useful result.

Black Box Factory in the stack.

Built on

Application architecture

A composable foundation where it suits the product.

Works with

Engineering knowledge

Reusable mechanisms and their assumptions.

Connected system

Development discipline

Harness practice and independent verification.

Technical reference5 mechanisms · 1 further section

The mechanisms underneath.

The technical choices that give Black Box Factory its particular behavior.

A mandate before an attempt
Scope, ceilings, budget and expiry are bound to an owner-confirmed mandate. The local Planner translates architectural direction into work the factory can admit.
Roles are separate principals
Coder, Reviewer and QA have distinct responsibilities. A result is challenged outside the author’s context; the merge authority checks the required verdict rather than accepting the author’s own success claim.
The handover is a record
Source-bound packets carry objective, implementation, checks and unresolved findings between short-lived attempts. Restarting a session does not require reconstructing intent from memory.
Reserve capacity for the challenge
Implementation and review compete for finite resources. Review capacity is reserved so a growing build queue does not consume the capacity needed to judge its results.
Acceptance follows the exact source
Repository gates, source identity, review evidence and intended delivery environment remain connected. A passing check on one revision cannot qualify a different change.

The brief becomes a set of inspectable artifacts.

Black Box organizes custom AI delivery around a client mandate, architecture, implementation, independent challenge and operational handover. Its selected factory design keeps acceptance tied to the exact change being judged.

The mandate. Define the work, operating boundaries and outcomes that acceptance must examine.

The architecture. Choose components, data contracts and integration points appropriate to the problem.

The accepted artifact. Bind the built software, review findings and QA evidence to an exact source and intended environment.

System story

From a hard problem to an accountable system

An illustrative custom-development journey from a recurring operational problem to handover.

Follow the story

Which operating problem should become a working system first?

Discuss a system to build