ENGINEERING LAB

Negency Engineering Lab

While client cases are still few, checkable engineering records are the trust asset. The Engineering Lab publishes Negency's technical samples in three evidence tiers — verified engineering assets, verifiable reference prototypes, and technical schemes & research.

Discuss my AI project
Negency Engineering Lab
Photo: KUKA industrial robot palletizing line, KUKA Roboter GmbH · Wikimedia Commons, Public Domain

The Engineering Lab is Negency’s public record of engineering verification, written for technical decision-makers and peers: every sample states, against one evidence standard, what it is, how far it is verified, what is still missing, and which code audit its conclusions rest on. Three evidence tiers: verified engineering assets, verifiable reference prototypes, technical schemes.

Forge proves control-plane engineering — orchestration, evidence governance, human-approval gating — not every scenario; the knowledge agent and industrial vision samples are still designs, with their verification status stated in each sample.

Evidence standard. The Lab is organised in three evidence tiers.

  • Verified engineering assets are real systems with internal run records.
  • Verifiable reference prototypes need a real runtime environment and regression tests before they are listed — that tier is currently empty.
  • Technical schemes are designs not yet verified.

Each tier states plainly what it is, how far it is verified, and what is still missing, so technical peers can inspect, reproduce, and challenge them.

Every sample follows the same eight items — purpose, architecture, technical approach, test environment, verified results, unverified scope, known limitations, next steps. No client cases are invented; no numbers are written without verification.

TIER 01

Verified engineering assets

Real systems, running internally, with checkable records.

SAMPLE 01

Negency Forge

Internally validated prototype

  1. Intake
  2. Hermes orchestration
  3. Staged execution T1–T3
  4. Frozen draft
  5. Human approval T4
  6. Controlled distribution T5
  • Audit baselinemaster 353c0f72 ·
  • Gate checks34 per run
  • Score1200 pts · mechanical diagnostic
  • Run record27/34 · 1085/1200 ·

Figures above are bound to the 353c0f72 baseline; main has since merged P4 and IMG-1, pending re-check in the next code audit.

FIG. FORGE DAG — 14 NODES

  1. 01Research
  2. 02Evidence normalisation
  3. 03Claim ledger
  4. 04Contradiction check
  5. 05Outline contest
  6. 06Writing
  7. 07Fact review
  8. 08Edit review
  9. 09Visual planning
  10. 10Chart tooling
  11. 11Visual review
  12. 12Render QA
  13. 13Human approval
  14. 14Publish and archive
Nodes and order taken from the Architecture section above; rendered in code, no illustration.

Purpose

Negency's in-house content production system: research, writing, visuals, review, and publishing as an orchestratable, auditable, checkable pipeline. The core judgement: content quality is a systems problem, not a writer problem — without gates and evidence, even good writers ship mistakes.

Architecture

Production path: request intake (idempotent receipt) → Hermes orchestration (leases + fencing) → staged execution T1–T3 → frozen master draft → human hash approval T4 → controlled distribution and learning feedback T5. The execution core is a 14-node deterministic DAG (research → evidence normalisation → claim ledger → contradiction check → outline contest → writing → fact review → edit review → visual planning → chart tooling → visual review → render QA → human approval → publish and archive), with stage checkpoints serialised as dataclasses, hash-verified, and resumable by another process. Task state is an explicit 14-state machine: illegal transitions raise errors, and every transition keeps a timestamped, sequenced history.

Technical approach

Python 3.10+ first, with a TypeScript hub alongside the main chain; layered storage across SQLite, Google Sheets, and Google Drive.

  • Evidence governance: a claim ledger manages factual claims one by one (type/risk grading, numeric firewall, provenance graph); a claim-lock gate fetches source texts to compare numbers and excerpts; each of the 12 scoring modules must carry replayable evidence (replay script + input/output paths + SHA-256 hashes), and a hash mismatch fails the check.
  • Gate integrity freeze: the SHA-256 hashes of 232 gate and production files are pinned in a manifest whose own hash is pinned in code, and the gate service verifies integrity before every run.
  • Human review is a hard gate: a publish approval counts only when issued server-side by Hermes T4, bound to a human reviewer's identity (signer whitelist), with the approval hash equal to the frozen draft hash; without approval the task waits and is never auto-issued; a worker cannot review its own task.
  • Quality gates: one gate run produces 34 check records (12 scoring modules + 7 reader checks + 10 visual-system checks + 5 independent gates); the 12 modules total 1200 points, and any veto item zeroes the total. The 1200 points are a mechanical diagnostic score — the code states explicitly that independent acceptance is still required.

Test environment

Repository ieyer/agy_workspace (private), master branch. Audit baseline for the Forge facts on this page: master 353c0f72 (code audit dated 2026-11-12, HEAD 9c6068b6 at audit time, re-checked to 353c0f72 before publishing; gate verdicts and thresholds unchanged); the gate code behind the 13 November 2026 run record was synchronised with master 353c0f72. Main has since merged P4 (c070c339) and IMG-1 (e4da8ccc); the numbers and conclusions above await re-check in the next code audit, and until then this page still states them on the 353c0f72 baseline. The test suite holds roughly 1,700+ test functions (sampled estimate), layered by pytest markers; CI runs contract, acceptance, and regression gates plus secret scanning on every push. The system is in internal use; Negency's WeChat batch content production runs through this pipeline.

Verified results

All six published modules have real code behind them: workflow orchestration, task state, evidence governance, review mechanism, execution logs (task-level JSONL triple-stream logs + domain event store + accountability ledger), and quality gates (34 checks + 1200-point mechanical diagnostics + fail-closed checks).

A complete record of one real production task dated 13 November 2026 is on this page (see "Real run evidence"): gate run 27/34 passed, independent acceptance 1085/1200, new draft delivered to the draft box with reconciliation PASS. A single-task record, not batch statistics.

Unverified scope

Runtime behaviour has a single-task record only: lease behaviour under real concurrency, gate pass rates on real articles, throughput, and availability are all unmeasured. The HTTP intake path has no observed real execution record. Consistency between the production run area and master is unchecked.

Known limitations

No claims of CMMI certification, production throughput, or 100% reliability — none has evidence. The 1200 points are a mechanical diagnostic score, not a substitute for independent acceptance and not a publish verdict. The test suite carries known failures, managed by a failure ratchet (only ever decreasing); full-suite green is not claimed.

Next steps

Continued convergence under the factory remediation programme: gates recalibrated against signed real drafts, image-pipeline automation, versioned releases; the production run area upgrades with each release. Facts here update with code audits, re-checking key conclusions whenever HEAD moves.

Real run evidence: content-production task, 13 November 2026

One real task, end to end — a company-owned content-production task, not a client task; task identifiers are desensitised. Run version: gate code synchronised with Forge master 353c0f72 (P5).

  1. Request submitted
  2. Task created
  3. Staged checkpoints
  4. Staged execution
  5. Review & approval
  6. Delivery
  7. Logs & failure handling
  • Request & task. A rewrite task was issued after a same-day board outcome (12 November 2026); the work branch was created the same day. Desensitised task identifier: NEG-…-20261113.
  • Staged checkpoints. Review package → minor revisions → gate code synchronised to master 353c0f72 → Phase A → endorsed gate run → bypass record → Phase B push; every step is a git commit with evidence files.
  • Staged execution. Phase A completed real image uploads and footer v3 (HTML SHA-256 prefix 9a52f6a1…); Phase B pushed a new draft without overwriting the old one.
  • Review & approval. Independent acceptance 1085/1200 (12 modules scored one by one, no veto items); 7 failed checks were ruled non-defects and bypassed with written approval.
  • Delivery. New draft delivered to the WeChat draft box (13 November 2026, 09:10 CST, UTC+8); reconciliation PASS — images 4/4, captions 3/3, references 12/12; the old draft stayed frozen and untouched (content SHA 4718bfd1… unchanged).
  • Logs & failure handling. Gate run 27/34 passed (endorsed run 17945138…c779); the 7 failures (anti_ai, figure_legibility, image_semantics, image_text_integrity, shareability, story, visual_quota) were recorded as mechanism false positives / calibration issues, not content defects; all other gates ran and passed as usual.
  • Test boundaries. Single-task record; no concurrency, throughput, or availability measurements. This evidence covers the work-branch + gates + push path; the HTTP intake path has no observed real execution record.

Scope note. Forge's content-production capability proves orchestration, evidence governance, and control-plane engineering — it does not automatically prove all enterprise Agent scenarios are validated. Run evidence is presented as a text record; no console screenshot is attached (the console requires login and has no public demo).

TIER 02

Verifiable reference prototypes

A prototype enters this tier only with a real runtime environment and regression tests.

This tier is currently empty. No sample meets both bars yet, so nothing is listed here. A design scheme is not promoted into this tier until it runs and is tested — the knowledge agent and industrial vision samples below stay in Tier 03 until then.

TIER 03

Technical schemes & research

Designs and research directions, stated as designs — not as validated systems.

SAMPLE 02

Knowledge & Workflow Agent

Design scheme

  1. Documents in
  2. Parsing
  3. Retrieval
  4. Model response
  5. Tool calls
  6. Permission control
  7. Human approval
  8. Execution result
  9. Audit record

Purpose

Connect enterprise documents, data, and workflows into a controllable agent system: an employee asks, the system retrieves knowledge, drafts an answer, calls tools to act — and stops for human confirmation at the steps that matter. The problem is not whether an agent can answer, but whether it may act: a wrong answer is cheap, a wrong write or execution needs someone accountable.

Architecture

Nine steps: documents enter the knowledge system → parsing → retrieval → model response → tool calls → permission control → human approval → execution result → audit record. Retrieval and execution are separated: the model only proposes; writes and executions pass permission checks and human approval; every step leaves a traceable record.

Technical approach

Retrieval uses RAG (knowledge-base retrieval plus model generation); execution uses tool calls (MCP/API connections to business systems); governance uses gated writes — reads and writes run in separate lanes, and a write executes only with permission and approval. The governance method is published in the Control Brief series: gated writes, permission debt, and agent routing. Which situations use retrieval, which use tool calls, and which require human approval is set out in the decision table at the end of this sample; the acceptance metrics table beside it lists the metrics, with thresholds agreed with the client before the pilot.

Test environment

Not yet built. This sample has no running test environment and no interactive online demo. The nine-step chain on this page is a design scheme, not a product screenshot; do not read it as a live system. A minimum verifiable prototype is filed as a separate R&D task (see "Next steps") and has not started.

Verified results

The governance method is published: three method notes — gated writes, permission-debt judgement, agent routing and kill switch — are out in the Control Brief series. That verifies the method on paper, not the system: a written method is not a running system.

Unverified scope

The full nine-step chain has not run in a test environment; retrieval accuracy, tool-call reliability, and the permission model against real business systems are all unverified; there are no performance or cost numbers.

Known limitations

No testing against real client data; no production run record; no promises on retrieval accuracy, response time, or delivery schedule. Numbers wait until a pilot measures them.

Next steps

The first step is a separate R&D task, "minimum verifiable enterprise knowledge agent prototype" (status: not started): public test documents → retrieval → sourced answers → simulated business tools → permission check → human approval → audit record. Seven verification cases: normal retrieval; no answer found; unauthorised call; tool-call failure; approval rejected; approval granted; audit-log recording. Only after all seven pass may this page upgrade its status to "internally validated prototype"; until then it stays a design scheme.

Once the prototype passes, pilots follow by client scenario: scenario diagnosis → small pilot (read-only retrieval first) → controlled-write pilot → decide whether to scale. Each step proceeds only on checkable acceptance criteria; a pilot that misses its criteria stops for rework instead of being pushed live.

Decision table: which handling for which situation

Design rules, revised as the prototype is verified — not measured behaviour.

SituationHandlingWhy
Question answerable from existing knowledgeRAG retrieval + cited sourcesAnswers stay traceable and correctable
Needs to read or change a business systemTool call (MCP/API)The model only proposes; calls pass permission checks
Involves a write, an execution, or an external sendHuman approval requiredA wrong write or execution needs someone accountable
No retrieval result, or confidence too lowSay so plainly; do not invent an answerBetter no answer than a wrong one

Acceptance metrics

Thresholds are agreed with the client before the pilot and written into the acceptance document.

MetricHow it is measuredThreshold
Retrieval accuracySampled human check of whether retrieved passages answer the questionAgreed with the client before the pilot
Citation rateShare of answers carrying source citationsSame as above
Tool-call success rateSuccessful calls / total callsSame as above
Approval latencyTime from approval request to human decisionSame as above
Audit-record completenessWhether every execution leaves a complete traceable recordSame as above

SAMPLE 03

Industrial Vision & Edge AI

Design scheme

Inspection camera inside a solder-paste inspection machine
Illustrative photo — inspection camera in a solder-paste inspection machine, not Negency equipmentPhoto Nelatan · CC BY-SA 3.0
  1. Image capture
  2. Edge inference
  3. Defect analysis
  4. Evidence archiving
  5. Human review
  6. Work order

Purpose

Make industrial visual inspection a verifiable loop: image capture → edge inference → defect analysis → evidence archiving → human review → work order. Every inspection verdict must be checkable and traceable: for each image judged defective, it must be possible to replay why it was judged so, who reviewed it, and which work order it entered. Black-box scores do not belong on a factory floor.

Architecture

Six steps: image capture (industrial cameras and sensors) → edge inference (models running locally on edge compute modules) → defect analysis (defect-type judgement + confidence + evidence image) → evidence archiving (original image + inference result + review record, kept together) → human review (a mandatory step — the machine never clears a defect alone) → work order (confirmed defects enter the work-order and maintenance system). Deployment shape follows the client site: public cloud, client private cloud, on-premises, or edge devices can all be assessed; data can stay inside the plant.

Technical approach

Edge inference first: models deploy on edge devices for low latency and offline operation, without cloud round-trips. Defect analysis outputs type, confidence, and evidence image together — never a lone score. Evidence archiving keeps the original image, the inference result, and the human review record for later trace-back. Human review is mandatory: no defect verdict reaches a work order without human confirmation. Equipment selection (cameras, sensors, compute modules) and work-order integration are assessed per project, with no single vendor presumed.

Dataset selection criteria: only licensed public datasets or client-authorised data; defect categories and labelling rules are fixed before model selection; train, validation, and test sets are separated, and the test set plays no part in tuning before acceptance.

Model validation process: offline validation first — detection accuracy, false-positive rate, and miss rate are measured on the test set, with thresholds set by acceptance metrics, not by demo effect; only after offline validation passes does the model move to an edge-device pilot; pilot results decide whether site acceptance proceeds.

Failure modes and handling (design, not measured results): false positives — rejected in human review and logged, with the review record feeding back into the labelling rules; misses — found by sampling and review, added as new samples, triggering offline re-testing; lighting changes — capture is calibrated for lighting first, and batches outside the calibrated range pause automatic judgement and go to human review; new defect types — never forced into an existing class, marked as unseen and routed to human review; whether a new class is added is decided by the labelling rules.

Edge hardware selection method: candidates are scored on inference latency, power draw, operating temperature, interfaces, and supply-chain availability, with no single vendor presumed; selection conclusions rest on pilot measurements, not vendor datasheets. Scoring dimensions are tabulated at the end of this sample.

Test environment

The offline validation environment is built (server CPU): the DeepPCB public dataset (MIT licence) is selected and a first offline validation run is complete. No test bench, no real devices, no edge-device pilot. The six-step chain and deployment shapes on this page are still a technical scheme, not a record of a running system.

Verified results

Offline validation, first run (2026-11-13): on the DeepPCB public benchmark (MIT licence; 500 normal vs 500 defective PCB images), a simple feature-embedding anomaly baseline reached image-level AUROC 0.627, detecting 11.8% of defective boards at a 6.6% false-alarm rate. Offline only; single dataset; weak baseline — not production performance. The five questions, updated: real model inference has been run (offline, once); one public dataset has been used (DeepPCB); one offline baseline has been verified; no real-device testing has taken place; no site acceptance has been completed.

Unverified scope

Edge inference, defect analysis, evidence archiving, human review, and work order — five of the six steps — are still unverified; model selection (one generic baseline run, no comparison); edge hardware selection; latency and long-run stability; integration with client work-order systems. Offline validation has run once on one dataset (DeepPCB), so detection accuracy and false-positive rate still have no deliverable conclusion. Each awaits pilot measurement.

Known limitations

Everything on this page is a technical scheme, not delivered capability; no promises on detection accuracy, false-positive rate, or deployment schedule.

Limits of the first run: offline only; one dataset, one product type (PCB); defects were artificially introduced by the dataset authors, not natural production defects; no site validation, edge-device testing, or latency measurement; training and testing shared board designs (split by pair, not by design). Conclusions do not transfer automatically to real factory imagery or other products. Dataset: DeepPCB, MIT licence, arXiv:1902.06197.

Functional safety and human-review boundaries: an inspection verdict never triggers equipment action directly; no defect verdict reaches a work order without human confirmation; safety-related judgements are never left to the model alone.

Equipment certification, functional safety, cybersecurity, and import/export compliance must be checked per product; no device is promoted as "fully compliant with EU and US regulations".

Next steps

Dataset selection (DeepPCB, MIT licence, selected) → offline verification (first run complete: AUROC 0.627, weak baseline — a measured floor only, not judged against acceptance thresholds, which are agreed with the client before the pilot) → edge-device pilot → site acceptance. Each step gates the next; pilot data decides whether the scheme continues — concept images never substitute for acceptance.

Acceptance metrics are tabulated at the end of this sample: detection accuracy, false-positive rate, miss rate, per-image inference latency, and continuous-run stability; thresholds are agreed with the client before the pilot starts and go into the acceptance document, and a measurement that misses reworks the scheme instead of lowering the bar.

Edge hardware selection scoring

Scoring dimensions from the text above; selection conclusions rest on pilot measurements, not vendor datasheets.

DimensionWhat the pilot checks
Inference latencyWhether per-image inference time meets line speed requirements
Power drawWhether full-load power and cooling fit site conditions
Operating temperatureWhether it runs stably across the site temperature range
Interfaces & supply-chain availabilityWhether it connects to existing line interfaces, and whether supply lead time is checkable

Acceptance metrics

Thresholds are agreed with the client before the pilot and written into the acceptance document.

MetricHow it is measuredThreshold
Detection accuracyShare of defects correctly detected on the test setAgreed with the client before the pilot
False-positive rateShare of good parts wrongly flagged as defectiveSame as above
Miss rateShare of defects not detectedSame as above
Per-image inference latencyEnd-to-end inference time per imageSame as above
Continuous-run stabilityRecord of fault-free operation over the continuous runSame as above

HOW THE LAB WORKS

How the Lab works

One method across all samples; the method itself is no substitute for verification.

Evidence tiers

What counts as verified: Tier 03 → 02 needs a real runtime environment and regression tests together; Tier 02 → 01 needs internal run records and a code audit. Promotion rests on evidence, never on plans.

Verification flow

Offline verification → pilot → acceptance: validate on test sets and in test environments first, then run a small pilot, then accept against the acceptance document; each step gates the next.

Failure handling

A measurement that misses its bar triggers rework, never a lowered bar; a pilot that misses its criteria stops for a revised scheme, never a forced launch; failures are written into the sample record, not hidden.

Versioned evidence

Every fact carries its audit baseline (code commit SHA) and review status; as code moves on, key conclusions are re-checked in the next audit, and no number is updated before that review.

NEXT STEP

Start from your scenario, not from our samples

Tell us the business problem first; we will tell you honestly whether it fits a pilot.