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
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
- Intake
- Hermes orchestration
- Staged execution T1–T3
- Frozen draft
- Human approval T4
- 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
- 01Research
- 02Evidence normalisation
- 03Claim ledger
- 04Contradiction check
- 05Outline contest
- 06Writing
- 07Fact review
- 08Edit review
- 09Visual planning
- 10Chart tooling
- 11Visual review
- 12Render QA
- 13Human approval
- 14Publish and archive
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).
- Request submitted
- Task created
- Staged checkpoints
- Staged execution
- Review & approval
- Delivery
- 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
- Documents in
- Parsing
- Retrieval
- Model response
- Tool calls
- Permission control
- Human approval
- Execution result
- 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.
| Situation | Handling | Why |
|---|---|---|
| Question answerable from existing knowledge | RAG retrieval + cited sources | Answers stay traceable and correctable |
| Needs to read or change a business system | Tool call (MCP/API) | The model only proposes; calls pass permission checks |
| Involves a write, an execution, or an external send | Human approval required | A wrong write or execution needs someone accountable |
| No retrieval result, or confidence too low | Say so plainly; do not invent an answer | Better no answer than a wrong one |
Acceptance metrics
Thresholds are agreed with the client before the pilot and written into the acceptance document.
| Metric | How it is measured | Threshold |
|---|---|---|
| Retrieval accuracy | Sampled human check of whether retrieved passages answer the question | Agreed with the client before the pilot |
| Citation rate | Share of answers carrying source citations | Same as above |
| Tool-call success rate | Successful calls / total calls | Same as above |
| Approval latency | Time from approval request to human decision | Same as above |
| Audit-record completeness | Whether every execution leaves a complete traceable record | Same as above |
SAMPLE 03
Industrial Vision & Edge AI
Design scheme
Full method, pilot plan and acceptance gates: Industrial Vision & Edge AI solution.

- Image capture
- Edge inference
- Defect analysis
- Evidence archiving
- Human review
- 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.
| Dimension | What the pilot checks |
|---|---|
| Inference latency | Whether per-image inference time meets line speed requirements |
| Power draw | Whether full-load power and cooling fit site conditions |
| Operating temperature | Whether it runs stably across the site temperature range |
| Interfaces & supply-chain availability | Whether 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.
| Metric | How it is measured | Threshold |
|---|---|---|
| Detection accuracy | Share of defects correctly detected on the test set | Agreed with the client before the pilot |
| False-positive rate | Share of good parts wrongly flagged as defective | Same as above |
| Miss rate | Share of defects not detected | Same as above |
| Per-image inference latency | End-to-end inference time per image | Same as above |
| Continuous-run stability | Record of fault-free operation over the continuous run | Same 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.