ZOMG, the agent found the interwebs

What We Worked On

There it was, sitting between a PowerShell file read and another rg command:

An AI coding agent working PLAN-019 had reached the edge of the repository, looked over it, and discovered that the rest of the world was still there.

ZOMG!!! :D

The plan was to build an SNMP health collector for HPE ProLiant servers and iLO. The local repository already had the architecture it needed: collector contracts, SNMP transport, timeout protections, worker registration, test patterns, and PLAN-018’s request planner. What it did not have was the right to make up HPE’s current object identifiers or assume that an enum copied from an old example still meant the same thing.

Verify every exact OID and enumeration against the current HPE MIB/update kit during implementation. Do not copy an OID from an example into code without a fixture showing its scalar/table instance suffix. — PLAN-019 acceptance criteria

That sentence is what opened the browser.

The TODO That Required An Outside World

Most implementation plans can be advanced by reading the codebase deeply enough. Find the seam, copy the established pattern, add tests, and keep going. This one contained facts the repository could not establish for itself.

The collector needed authoritative answers for overall health through cpqHeMibCondition; thermal and fan condition; individual fan and power-supply tables; physical-memory and DIMM condition; processor status; physical-drive condition; scalar instance suffixes; table indexes; and the enum vocabulary attached to every individual object.

The last item matters more than it looks. A raw integer such as 3 is not a universal word for “degraded” just because one HPE object uses it that way. PLAN-019 requires an object-specific translation into one stable metric:

That tiny gauge sits on top of several different MIB vocabularies. If the translation layer is wrong, the simplicity of the output makes the mistake more dangerous, not less. A clean 1 can conceal a great deal of invented confidence.

The First Few Steps Were Extremely Computer

The historic voyage did not begin with violins. It began with a Windows glob that rg did not like:

Then a guessed test-project path did not exist. Then a guessed abstractions filename did not exist either.

This is part of why the transcript is so good. The agent did not become omniscient when the browser appeared. It remained a working craft agent: forming a hypothesis, asking the filesystem, receiving a small slap, and adjusting.

It replaced the invalid Windows wildcard with a repository-wide search and a file filter. It found the actual tests under LogSinkNSearch.Collectors.Tests. It found the real contract filenames. It read the existing SnmpCpuLoadCollector, SharpSnmpClient, worker registration, coordinator, metric observations, and fixture patterns.

Searching Was Only The Doorway

The first web queries were almost comically modest:

Search results could locate the neighborhood, but PLAN-019 did not authorize implementation from snippets or examples. The source needed to be current, primary, and exact.

So the agent opened HPE’s Support Center page for the Integrated Lights-Out Management MIB update kit. The visible page showed version 2.11.0.0, released April 10, 2026, and described it as the Gen10 and Gen11 MIB kit for HPE Systems for Windows.

Then the browsing became engineering. The agent inspected the page’s network requests, found the public software-detail endpoint, and read the response behind the support UI:

This is the wonderful bit. It did not stop at “the page says there is a download.” It followed the site’s own data path until the current release and archive were concrete enough to verify.

The four-color search-engine moment had done its job. Now the palette changed to HPE green.

Downloading Reality

HPE’s current support entry exposed a public, checksum-pinned archive. The agent downloaded MIBKIT_2.11.0.0.exe into a task-specific temporary directory, computed its SHA-256 hash, expanded it, and selected the Gen11 MIB set.

The transcript does not preserve the displayed hash value, so this post will not invent one. What matters here is the evidence chain: current HPE release page, public archive, computed digest, extracted primary MIB text.

The agent searched the actual OBJECT-TYPE definitions, not a copied OID list. It inspected enum blocks for cpqHeMibCondition, cpqHeThermalTempStatus, cpqHeThermalSystemFanStatus, cpqHeFltTolFanCondition, cpqHeFltTolPowerSupplyCondition, cpqHeResMem2ModuleCondition, and cpqDaPhyDrvCondition.

Then it inspected the table INDEX structures for fan, power supply, memory, CPU, and physical drive. That is what turns “this column exists” into “this is the exact instance suffix a fixture and bounded walk must demonstrate.”

The browser had not supplied code. It had supplied reality.

What The Agent Was Protecting Us From

The funny version is that the agent discovered Google. The serious version is that it refused several easy ways to lie.

One enum to rule them all

It could have created a generic HPE condition mapper and declared that raw values mean the same thing everywhere. PLAN-019 explicitly forbids this. The agent verified each object’s vocabulary separately.

Missing means healthy

It could have treated an unsupported OID, empty table, timeout, or authorization failure as absence of bad news. The plan says the opposite: emit no fabricated ok. Unsupported, partial, and failed results remain visible.

A scalar is just a short table

It could have copied numeric roots without proving whether a scalar needs its instance suffix or a table column needs a bounded walk with an index. The MIB inspection exists specifically to keep that error out of code and fixtures.

Average the hardware

It could have averaged ordinal component states into a reassuring number. Instead, aggregate state may come only from a documented HPE overall object or an explicitly tested worst-of-components policy.

Ask Windows for everything

It could have depended on the legacy cpqWinOSMgmt tree. The plan cites HPE’s advisory that those objects are unavailable through AMS on affected Gen10, Gen10 Plus, and Gen11 systems. Direct iLO polling is the preferred path; the Windows agent route remains a separately documented legacy alternative.

Out Of TODO Does Not Mean Out Of Evidence

The transcript ends with:

That is worth preserving because we do not need to fake a triumph to have one. At the cutoff, PLAN-019 was not yet a completed collector with passing fixtures and a hardware-backed iLO test. No commit hash exists in the supplied record, and this post will not manufacture one.

What changed was the plan’s epistemic state.

Before the browse, the remaining design check was an unresolved dependency on current external facts. After the browse, the agent held the primary MIBs, their release identity, the relevant object definitions, the enum text, and the table index structures. It could return to the repository and implement a versioned HpeProLiantOidProfile without pretending memory was documentation.

That is how a good plan comes out of TODO: not because a checkbox gets dragged across a board, but because every fact needed to justify the implementation becomes reachable.

What Went Well

The agent noticed the knowledge boundary. It did not confuse extensive repository context with authority over a vendor’s current MIB.

It escalated the research method in sensible steps. Search found the support page; browser inspection found the public API; the API led to the archive; the archive yielded the primary definitions.

It kept provenance attached to the profile. The planned code records the MIB kit version and date next to the OIDs instead of leaving unexplained numbers in a static class.

It researched the runtime shape, not just names. Scalar suffixes, table indexes, subtree bounds, and per-object enum mappings all received attention.

It kept partial support honest. Different ProLiant generations expose different objects. The design treats that as expected operational information, not as permission to emit green.

What Didn’t Go Well

The opening repository searches guessed Windows paths and globs. They failed harmlessly, but a direct repository-wide file inventory would have reached the real layout faster.

The initial web searches were not sufficient evidence. That was expected, but it demonstrates why “browse the web” is not one operation. Discovery and verification are different phases.

The current-release claim is time-bounded. Version 2.11.0.0 was current on July 29, 2026. The point of versioning the profile is that future HPE releases can change that fact.

The transcript stops before implementation proof. No collector code, fixture suite, --once output, or opt-in hardware test is shown here. The next agent still has to finish the work and preserve the evidence in tests.

Takeaways

1. 1
   The repository is not the universe

   Local search can reveal code facts. It cannot certify a vendor’s current protocol definitions.

2. 2
   Browsing is a research pipeline, not a magic verb

   Search, page inspection, network inspection, archive verification, and source reading each answer a different question.

3. 3
   Primary sources make simple metrics trustworthy

   The smaller the public gauge, the more carefully its lossy normalization must be sourced.

4. 4
   Unknown is a first-class health state

   Missing, unsupported, timed out, and authorization-denied are not synonyms for healthy.

5. 5
   Per-object enums beat clever generic mappings

   Repeated integer values are not shared semantics.

6. 6
   A plan leaves TODO when uncertainty becomes testable

   Code comes next, but the important transition is from assumption to evidence.

7. 7
   ZOMG, the agent can use the interwebs

   Apparently we are living in the future, and the future is reading cpqhlth.mib on purpose.