NUMINANCE / AUTONOMOUS ENGINEERING

Give it context.
Let it engineer.

Numinance is building an autonomous AI software engineer that understands your codebase before it acts, then takes engineering work as far as you authorize—from proposing changes to production operations. Policy sets the limits. Evidence lets you check the work.

Explore the open spec See how it works

Not another coding assistant. Engineering you can delegate.

PRE-ALPHA / ENGINE IN DEVELOPMENT

Code generation was never
the whole job.

Generating code is one thing. Understanding a system, navigating its dependencies, respecting its constraints, and taking responsibility for the outcome is engineering.

Numinance is being built for the whole job: understand, plan, implement, verify, release, observe, recover, within the authority you configure.

engineering-compare.sch

concept illustrationsame request, two ways to handle it

APROMPT → CODE

PROMPT

one message

CODE

generated

OUTPUT

unreviewed

done in one step — and nothing else happened

stages: 1policy: nonereviewed: noevidence: none

BINTENT → ENGINEERING SYSTEM → VERIFIED OUTCOME

INTENT

goal + limits

UNDERSTAND

read the system

PLAN

scope + risk

ACT

scoped tools

POLICY GATE

hold or release

VERIFY

checks + review

RECORD

evidence slip

VERIFIED OUTCOME

change + receipt

stages: 6policy gate: releasedreviewed: yes — independentevidence: 1 record

CONTEXT FIRST
Architecture. Dependencies. Conventions. Constraints. Understand what already exists before deciding what should change.
AUTONOMY BY DESIGN
From suggestions to independent execution, the level of responsibility is configurable—not hard-coded into a chat session.
ACCOUNTABLE EXECUTION
Every permitted action belongs to a governed workflow, from plan to release, observation and recovery. Verification and evidence are part of the engineering process.

intent received A task goes in.
Accountable work
comes out.

From declared intent to governed tool execution, typed contracts, and evidence, Numinance is designed to carry engineering work through a controlled process—not bounce responsibility back to the next prompt.Less prompting. More engineering.

engineering-run.rigpre-alpha

01 / INTENTschemas/examples/AutonomyPolicy/org-ladder.yaml

schemas/examples/AutonomyPolicy/org-ladder.yaml

apiVersion: numinance.dev/v1
kind: AutonomyPolicy
metadata: {name: org-ladder, scope: SCOPE_ORG}
spec:
  defaults: {level: AUTONOMY_LEVEL_PR}
  rules:
    - {match: {playbook: dependency-upgrade,
               risk: RISK_CLASS_LOW},
       level: AUTONOMY_LEVEL_MERGE}
  floors:
    rules:
      - {match: {risk: RISK_CLASS_HIGH},
         max_level: AUTONOMY_LEVEL_SUGGEST}
      - {match: {environment: production},
         max_level: AUTONOMY_LEVEL_MERGE}

02 / AUTHORITYdecided by the host

requested actionplaybook: dependency-upgradevia numinance.ports.scm

RiskClass

READLOWMEDIUMHIGHPRIVILEGED

DecisionOutcome

ALLOWDENYREQUIRE_APPROVAL

pending

AutonomyLevel · default PR, rule → MERGE

OBSERVEOPERATE

PrincipalKind · separation

AUTHOR_AGENT≠REVIEWER_AGENT/HUMAN_APPROVER

the decision is made outside the model

03 / EXECUTIONnuminance.plugin.v1

Envelope {
  method: numinance.ports.scm.v1 …
  context: ActionContext {
    invocation_id:      inv_…
    change_id:          chg_…
    actor_kind:         PRINCIPAL_KIND_AUTHOR_AGENT
    grant_id:           grant_…
    policy_decision_id: dec_…
    plan_digest:        …
  }
  request: Any
}

PluginService.Invoke(server-streaming)HostService.EmitEvidence

context is set by the host after the policy decision — the plugin never supplies it.

04 / EVIDENCEevidence/v1

hash-linked to 2 earlier records

$numi evidence verify --runner-key FILE --log-key FILE --log-origin ORIGIN DIR

unauthenticatedself-consistentverifiednot run

verified needs caller-pinned keys; a key from the export never reaches it. Without them the best level is self-consistent or unauthenticated. Evidence docs

UNDERSTAND
Know the system first.
Resolve relevant repository structure, dependencies, documentation, and constraints.
PLAN
Turn intent into a plan.
Define scoped work, risk, execution steps, and checks.
ACT
Work within the authority granted.
Dispatch permitted work through scoped capabilities and adapters.
VERIFY
Check the work, not the explanation.
Run deterministic checks and independent reviews, with bounded repair where permitted.
EVIDENCE
Leave a record others can inspect.
Record what was attempted, allowed, denied, and observed.

Where checks fail, repair is bounded and recovery is explicit; rollback is part of the lifecycle, not an afterthought. Everything shown is illustrative.

conceptual visualization · pre-alphaProtocol docs Evidence docs

policy gate Turn autonomy up.
Never turn control off.

Choose how far Numinance may go—from observation and suggestions to implementation, merging, releases, and operations. Risk, environment, scoped grants, and external policy determine how much authority each action actually receives.

Your policies decide. Not the model.

From OBSERVE to OPERATE.

Full autonomy is configurable, never assumed. Floors, the host sandbox ceiling and scoped grants always hold, and the model never grants itself more.

policy-gate · concept demonstration

GATE READOUTSillustrative · risk row: RiskClass member

01
requested operation
· · · · · ·
02
scope
· · · · · ·
03
risk
· · · · · ·
04
grant
· · · · · ·
05
policy
· · · · · ·
06
required approval
· · · · · ·

RESULT

— — —

AUTONOMY LADDERillustrative · AutonomyPolicy

requested level · cap · effective level

SCOPED GRANT· · ·

Select a level to request it. Configuration never lifts a floor or the host sandbox ceiling, and a level is never a grant.

GATE PRINTER

waiting for a request…

MODEL / AGENT

No override path. The decision sits outside the model.

concept demonstration — not a production runstamps are display text · outcomes map to DECISION_OUTCOME_REQUIRE_APPROVAL / _ALLOW

separation of duties · interlock

01
author
proposes the change
proposed the action
02
independent reviewer
not the author
independent of author
03
release identity
the only identity that deploys
holds the release
04
human approver
approves; accepts autonomy promotion
required · pending

the author cannot approve its own work

The author cannot approve its own work. The interlock separates who proposes, who reviews, who releases and who approves. Illustrative diagram of the design intent.

customer-controlled execution Your infrastructure.
Not our playground.

Numinance is designed to put the engine, runners, credentials and execution behind your boundary. The model can propose work; the fixed trust kernel decides what may happen. Your release pipeline deploys. Your systems keep the evidence.

Intelligence is not authority. Replace the worker. Keep the controls.

Engine

Trust kernel

Configuration

Adapters

Evidence

Execution boundary

1 POLICY2 BROKER3 HOST4 WRITER5 BREAKER

Illustrative architecture / pre-alpha design

Your engineering runtime

EngineProposes bounded workprivate

Trust kernelFixed. Inspect onlyfixed

ConfigurationYours to edityours

AdaptersReplaceable, behind typed portsswap

Executor

Source + CI

Context

EvidenceVerified outside the runtimefixed

Execution boundaryWhere work runsyours

Architecture overview →/docs/architecture →

verifier idle Don't trust the agent.
Check the evidence.

An explanation isn't proof. Numinance's open evidence model is designed to make engineering records independently inspectable, with cryptographic trust established using keys the verifier chooses—not keys the engine asks you to trust.

The result should stand on its own.

evidence-verifier · simulated evidence · concept demonstration

Trust roots:

terminal · illustrative output

$numi evidence verify --runner-key FILE --log-key FILE --log-origin ORIGIN DIR

The verifier operates on an evidence/v1 export directory, not an arbitrary JSON file, and it needs a key mode (without one it exits 2). Output above is simulated.

verification result

AWAITING RUN

Records are inspected one by one, then compared against trust material the caller pinned.

01…02…03…04…05…TRUST…RESULT…

Hash links prove structure only. They never establish authenticity. A result is plain-language and illustrative here; real levels: verified, failed, unauthenticated, self-consistent, incomplete, unsigned, unanchored.

EVIDENCE-EXPORT/ evidence/v1 directoryuntrusted input

EMBEDDED KEY · UNTRUSTEDTravels inside the export. It cannot vouch for the export.

TRUST BOUNDARY · COMPARE

CALLER-PINNED TRUST MATERIAL

runner key(s)standing by
log keystanding by
originstanding by

Supplied by the caller, outside the bundle. This is the only source of trust.

ARTIFACT INSPECTORVERIFICATION RESULT

recorded digest: sha256:4e07…ba3c
recomputed: not yet read
predecessor link: not yet read

checksrecorded as passed (illustrative)
claimsnone about authenticity
refers toartifact digest
illustrative fields · not the evidence/v1 schema

simulated evidence · concept demonstration · digests are placeholdersready

Evidence overview →/docs/evidence →

The brain is private.
The contract is open.

Numinance's intelligence engine remains proprietary. The public specification defines the protocols, configuration schemas, SDKs, integration contracts, conformance tooling, and independent evidence verification boundary.

Build against the contract. Not our internals.

PRIVATE ENGINE

Proprietary. Not in the repository.

NUMINANCE-SPEC / APACHE-2.0 / PUBLIC

proto/
schemas/
sdk/go
sdk/python
sdk/typescript
cli/
conformance/
plugins/
rfcs/
docs/evidence/

numinance-spec on GitHub Protocol SDKs CLI Governance

open CLI Build the integration.
Not another workaround.

Typed protocols. Explicit schemas. SDKs. Conformance tooling. An open CLI for configuration validation and offline evidence verification. The boundaries are defined so developers can build against them.

The engine is private. The integration surface is yours to explore.

Explore numinance-spec

go run ./cli/numi validate --files schemas/examples/SDLCProfilego run ./cli/numi validate --files schemas/examples/SDLCProfile

from cli/README.md · schema + loader checks only

SOURCEnuminance-specschemas/examples

2 files

IDLE

2/2 landed

schemas/ · illustrative layout

schemas/
examples/
SDLCProfile/
payments-api.yaml
org-baseline.yaml

schemas/payments-api.yaml

schemasexamplesSDLCProfilepayments-api.yaml

# illustrative — not captured from a run

apiVersion: …

kind: …

metadata:← corrected

name: <name>

spec:

…

extensions: …

RESULTafter the edit

files: 2 files checked
diagnostics: 0
schema (open CLI): <pass>
profile resolution: not covered · private engine
readiness: not implied

A schema pass says nothing about policy resolution.

illustrative — not captured from a runidle

DISCLOSURE File names, file contents and results here are illustrative and use placeholders; nothing was captured from a run. Open-CLI schema validation is not private-engine profile resolution, and neither is readiness. Hash links prove structural consistency only; a result is verified only against caller-pinned keys (there is no built-in trust root). /docs/cli /docs/evidence

messages received 4/4 Don't just watch the future.
Challenge how it's built.

The specification is public. The engineering decisions are open to scrutiny. Read the contracts, question the boundaries, challenge the assumptions, and help shape what accountable autonomy should look like.

The best systems survive scrutiny.

rfc-review.md

RFC / REVIEW

Found a weak assumption? Challenge it before it becomes a contract.

Read the RFC process

voice / featured

Quote pending approval
Not yet published. Nothing is attributed until it is approved.

David ShainidzePrincipal Engineer at Fundbox

Individual attribution. No company endorsement.

status.txt

STATUS / PRE-ALPHA

The architecture is public for scrutiny. The autonomous engine is still in development.

No customers, adopters or endorsements are claimed. Nothing here is a benchmark or a certification.

See what has changed

adapters.md

CONFORMANCE / CONTRIBUTE

Compatibility should be demonstrated, not assumed. Help shape the checks.

Read about conformance

illustrative session — not captured from a run

[ ok ] display 80x24

[ ok ] terminal ready

$ numi evidence verify --runner-key FILE \

--log-key FILE --log-origin ORIGIN DIR

reading DIR ...

hash links: <structural check>

keys: <pinned by the caller>

result: <illustrative placeholder>

no built-in trust root.

# from cli/README.md

$ go run ./cli/numi version

# from cli/README.md

$ go run ./cli/numi validate --files \

schemas/examples/SDLCProfil

NUMINANCE · N-1

Autonomy is the goal.
Accountability is the rule.

We're building beyond prompts toward engineering you can delegate. Explore the public protocol, understand the boundaries, and see how independently verifiable autonomy is taking shape.

$numi evidence verify --runner-key FILE --log-key FILE --log-origin ORIGIN DIR

Explore the specificationExplore the architecture View on GitHub ↗

NUMINANCE / BUILDING AUTONOMOUS ENGINEERINGEND OF SHEET SET

Give it context.Let it engineerengineerengineer.

Code generation was neverthe whole job.

CONTEXT FIRST

AUTONOMY BY DESIGN

ACCOUNTABLE EXECUTION

intent received A task goes in.Accountable workcomes out.

UNDERSTAND

PLAN

ACT

VERIFY

EVIDENCE

policy gate Turn autonomy up.Never turn control off.

From OBSERVE to OPERATE.

customer-controlled execution Your infrastructure.Not our playground.

verifier idle Don't trust the agent.Check the evidence.

The brain is private.The contract is open.

open CLI Build the integration.Not another workaround.

messages received 4/4 Don't just watch the future.Challenge how it's built.

Autonomy is the goal.Accountability is the rule.

Give it context.
Let it engineer.

Code generation was never
the whole job.

intent received A task goes in.
Accountable work
comes out.

policy gate Turn autonomy up.
Never turn control off.

customer-controlled execution Your infrastructure.
Not our playground.

verifier idle Don't trust the agent.
Check the evidence.

The brain is private.
The contract is open.

open CLI Build the integration.
Not another workaround.

messages received 4/4 Don't just watch the future.
Challenge how it's built.

Autonomy is the goal.
Accountability is the rule.