An inspection agent
that remembers.

Solar panels fail slowly. A cell cracks, a hot spot spreads, dust builds up over a season. Every one of those is obvious when you compare against last time, and nearly invisible in a single photograph.

Field inspection today produces photographs, not comparisons. A technician walks the site, shoots what looks wrong, and files a report. The next visit starts from zero — a different technician, a different angle, a different hour of daylight. Nobody compares against last time, because nobody kept last time in a form you can compare against.

So degradation is caught when it becomes visible to a person standing in front of the panel, which is long after it became measurable.

The agent keeps a baseline for every asset it has ever seen. When a new capture of panel A-114 arrives, it does not analyse that photograph in isolation — it aligns it against the stored image of that same panel and reports what moved.

That is the whole idea, and it is deliberately narrow. Every award-winning entry in previous editions analyses one frame or one session. The same asset, seen again three months later is empty ground.

The agent is not a classifier with a report attached. At four points in the loop, a number computed by OpenCV changes what happens next — the capture gets rejected, a different detector gets tried, the agent zooms into a region it chose itself, or a human is asked before anything is filed.

Each tool answers one question an inspector would ask, in the order they would ask it.

None of those five functions returns a verdict. Not one of them says "this photo is bad" or "call a technician". They return numbers only.

That sounds backwards, and it is the most deliberate choice in the codebase. The award's bar is explicit: the visual evidence must be shown to change what the system does next. If the threshold were buried inside assess_quality(), there would be nothing to show — just a function that returned False for reasons of its own.

Keeping the numbers and the thresholds apart means every decision reduces to one line that a judge can read without trusting anybody:

{"input_metric": "inlier_ratio",
 "value": 0.038,
 "threshold": 0.3,
 "branch": "unrecognized_asset"}

Alignment is the load-bearing step — everything downstream assumes the two frames are the same panel. Here is what it actually scores, run on this hardware, against synthetic panels where the ground truth is known.

On a correct match the alignment lands within 0.38 pixels of where it should. The neural detector returns 1000 keypoints with 128-dimension descriptors and costs about 1.5 seconds per pair on CPU — OpenCV 5's DNN engine has no GPU support, so the whole system is designed for Graviton from day one.

Three things in that table were not what the code assumed. Each one was found by running it, and each one changed the design.

Everything the agent knows about a panel lives in one place: a single database partition per asset, so its complete history — every inspection, every baseline it ever had — comes back in one query. Images live in object storage, filed by asset and inspection, and every derived artifact (the aligned frame, the validity mask) is stored next to the capture that produced it. A run can be reconstructed from storage alone.

A baseline is never overwritten. When a new capture earns baseline status, the old one is marked superseded and stays — the chain of superseded baselines is the longitudinal record, the thing the project is named after. And memory stores no expiry dates and no verdicts: deciding that a baseline is too old is a threshold, and thresholds belong to the policy, same as everywhere else.

The loop is now running. A language model drives the six instruments over MCP — it chooses the words for the operator and passes the arguments along. What it does not do is decide. After every tool result, plain code compares the numbers against the policy's thresholds, writes the verdict into the run's decision log, and hands the model the verdict it must follow. A model that tries to conclude something the numbers do not support gets its submission rejected, with the mandated branch named in the refusal.

This is the field manual's earlier promise kept: perception reports, policy decides, and the model narrates. Here is a real run — a faint spot, painted 22 grey levels deep, on a capture taken from a different angle:

{"input_metric": "blur_variance",  "value": 173.7,  "threshold": 100,  "branch": "quality_ok"}
{"input_metric": "inlier_ratio",   "value": 0.9987, "threshold": 0.9,  "branch": "aligned"}
{"input_metric": "mean_delta",     "value": 32.68,  "threshold": 35,   "branch": "crop_and_rescan"}
{"input_metric": "area_ratio",     "value": 0.7237, "threshold": 0.02, "branch": "change_confirmed"}
{"input_metric": "score",          "value": 0.2431, "threshold": 0.4,  "branch": "auto_write"}

The fourth branch is the one that stops the machine. When severity crosses its bar, nothing is written: the run parks itself as awaiting approval with everything a reviewer needs, and only an explicit yes commits the inspection and promotes the new baseline. The endpoint is open so a judge can use it without an account, so the gate checks the policy and not an identity: whoever holds the link can resolve it. The approval — or the rejection — is recorded as a decision like any other, with the human as the metric and an anonymous fingerprint of the caller alongside it.

The decision log answers what was decided. The trace answers everything else. Every run leaves runs/<run_id>/events.json: one event when the run starts, one span per tool call — the arguments sent, the metrics returned, the milliseconds it took, and the policy verdict nested inside the span it judged — and one event when the run ends. The human gate leaves events too: the approval request, and the yes or no that resolved it. Timestamps come from the server, never the viewer, and the file on disk is the source of truth — the trace survives a restart and travels as a link.

Here is the run that refused to recognize a foreign panel. The neural matcher voted, the policy sent the agent back for a second opinion, and the classic matcher settled it:

[2026-08-26T22:32:03.493+00:00] run e860a6bbd44a started  asset=demo-50ea63  capture=assets/demo-50ea63/capture/capture.png
[2026-08-26T22:32:03.896+00:00] assess_quality (79.7 ms)  blur_variance 322.547 >= 100.0 -> quality_ok
[2026-08-26T22:32:05.108+00:00] align_to_baseline (1212.2 ms)  inlier_ratio 0.4074 < 0.9 -> retry_classic
[2026-08-26T22:32:05.133+00:00] align_to_baseline (24.2 ms)  inlier_ratio 0.0385 < 0.3 -> unrecognized_asset
[2026-08-26T22:32:05.133+00:00] run finished: completed (unrecognized_asset)

The same trace is served over HTTP. GET /traces/<run_id> returns the raw events as JSON; a browser sending Accept: text/html gets the same run rendered as a page, with the causal line highlighted on every span. Anything that is not a well-formed run id — twelve hex characters — is a 404 before the filesystem is consulted, and the endpoint reads from disk on every request, so the same run always returns the same bytes. Without a server, python -m services.observability.render <run_id> prints the text rendering above; the runs root is configurable with AFTERIMAGE_RUNS_DIR.

Everything above happens inside a single container image on one AWS Lambda function. There is no separate inference service, no queue, no orchestrator: the agent loop is a function call made while your upload is still open, which is why the trace is ready by the time the page redirects. The same diagram opens the technical report.

That function sleeps when nobody is using it, and waking it costs 2.34 s — the median of 211 cold starts across the fortnight of logs the group holds. Awake, the function itself answers in 4 ms; the 0.58 s quoted at the top of this page is that plus the round trip to us-east-1, which is the larger share. The EventBridge rule in the diagram exists to keep the awake number the one you get, and the evidence that it works is not the headline ratio — 4.3% of invocations paid an init, but most of those invocations are the warmer's own — it is that no request which paid one was ever an inspection. The longest was 295 ms.

An inspection is the one number no warmer can move: 20.4 s at the median, 27.1 s at worst. About 8 s of it is ALIKED and LightGlue on a CPU and the rest is Gemini deciding, and it is why the page streams the trace instead of spinning. It bills 20.38 seconds at 2 GB, which at the published arm64 rate is $0.0005 a run — in practice nothing, because the whole function burns 2,381 GB-s a fortnight against the 400,000 a month AWS never charges for. The account's bill is image storage, near $0.10 a month. Where each of these figures comes from.

A handful of commands, no cloud account, no credentials. The neural matchers need two ONNX files that are not bundled in the OpenCV wheel; the first command fetches them and checks their published SHA-1.

make weights   # 52 MB of ALIKED + LightGlue models
make test      # the suite, inside the arm64 container
make demo      # the four branches, fired one by one
make dev       # the stack up, trace endpoint on :8000

Expect the complete suite to pass on aarch64 with OpenCV 5.0.0. The exact count changes as coverage grows, so make test is the source of truth. Unit tests use synthetic solar panels with controlled defects, while evaluation scenarios also include committed photographs and remain reproducible offline.

One thing worth checking, because it is the honest way to read a green suite: the tests that exercise the neural path skip themselves when the model files are missing. If make weights did not run, the suite still passes — with the interesting half untested.

make demo is the loop's closing argument: four prepared scenarios — a blurred capture, a foreign panel, a faint spot, a deep crack — each driven through the real MCP server and the real memory, each ending on a different branch, each printing its full trace — spans, durations, verdicts, and the human resolution where the gate fires. By default a scripted driver follows the verdicts so the run is deterministic; with a Gemini API key, --live puts the model in the driver's seat over the same loop. The verdicts are computed in code either way.

The loop closes, explains itself, runs in public, has a score, and has the competition report that explains it end to end: the technical report, which is where this manual sends you when you want the numbers rather than the plain-language version, and the three-minute walkthrough if you want neither. The implementation is documented separately for maintainers.

Start with the functional guide, then use the technology stack, architecture, backend guide, and frontend guide for the current system rather than the historical build plans.

Three shorter documents answer the questions this manual deliberately does not: responsible use and limits — what the agent is for, what it is not, and what its numbers do and do not let anyone claim; the security model — a public endpoint by design, what is checked before anything is stored, and what the deploy role can reach; and the use of AI — what the model decides inside the product, what it cannot decide, and what was verified by hand while building it.

• Defect classification is a threshold heuristic over OpenCV features, not a trained classifier. It is measured on 29 scenarios, eighteen of them real photographs of solar modules: macro F1 0.8542, with precision at least 0.75 on all four defect classes. Most of the suite is photographic — but every lesion in that set was injected by us, so this measures robustness on real texture, not field detection rates.
• inlier_ratio is not comparable across detectors, so the policy holds one threshold per detector — 0.90 for the neural pair, 0.30 for ORB — never a shared one.
• Frame coverage is estimated from the bounding box of the largest edge contour, and week 7 showed why that check still ships disabled: across healthy real photographs it reads anywhere from 0.0032 to 0.6357, a two-hundred-fold spread on images that are all perfectly usable. No single default separates a good capture from a badly framed one, so it stays a per-site setting rather than a promise.
• The agent scores 0.8621 on picking the right branch, and it never once asked a human to look at something that did not warrant it. It fails in four ways worth knowing: a half-framed photo gets rejected for the wrong reason — on a generated panel and on a photograph alike — a very bright defect can trip the exposure check before anyone looks at the defect itself, a small but serious defect can be filed automatically instead of escalated, because severity scores how much changed and ignores what its own classifier just called it, and soiling on a photograph is labelled a hot spot, because the rule that recognises dirt asks whether the change covers a quarter of the frame and real dust breaks into fragments that never do.
• crop_and_rescan buys measurement precision on a marginal region. It cannot resolve optical detail the original capture never recorded — no amount of zoom invents pixels.