[ T-03 // TRACK ]
AIP
AIP Logic, Chatbot Studio, and AIP Evals. The thinnest official docs.
- [ FM-AIP-01 ]
The LLM Is a Block Now: A Logic Function That Triages Work Orders
We built and published a live AIP Logic function that turns a free-text maintenance note into structured triage JSON, and ran it three times against notes of escalating severity. Verified live: CRITICAL for condensate leaking onto an electrical panel (9.35s, 145 prompt tokens), LOW for a flickering break room bulb (3.72s), CRITICAL for a server room at 31C with racks thermal throttling (3.75s). We also mapped the full block catalog (21 categories, 350-plus blocks), captured the 50-plus model list with context windows and rate limits, and confirmed the boundary that shapes every Logic design: Logic cannot read datasets. Data comes in through function inputs or the ontology.
- [ FM-AIP-02 ]
The Agent Gets a Tool: Wiring a Logic Function Into Chatbot Studio
We took the published FM-AIP-01 triage function and wired it into a chatbot in AIP Chatbot Studio. The build hit one real wall: the Call function picker could not find our function, by display name or API name, because the function was never bound to an ontology. The picker search is ontology-scoped and the Source filter only browses repositories and compute modules. Binding the function to the enrollment ontology and republishing fixed it in seconds. Verified live after the fix: the chatbot called the function on an emergency note and returned CRITICAL / ELECTRICAL in 3.75s with the JSON visible in the tool trace, asked a follow-up question instead of guessing on an ambiguous note, then triaged the follow-up detail as HIGH / PLUMBING. Chatbot published as v1.0.
- [ FM-AIP-03 ]
Grade the Agent: AIP Evals From Suite to Regression
We published the FM-AIP-02 chatbot as a function, which is the gate that unlocks evaluation, then built an evaluation suite with the stringContainsAllKeywords evaluator and three test cases taken from verified live traffic. First run: 3 passed, 0 failed, average 14s 477ms per case. We then changed one keyword to force a failure and the suite caught it: the agent answered LOW while the test demanded MINIMAL, red X, correct behavior. One real field repair: we clicked Run while a suite save was still in flight and the run executed the stale definition, failing a case that was already fixed. Final state: suite green, 3 of 3, saved in the project. Hard limit found: chatbot functions report no token or compute metrics to evals, every cost column reads No value.
- [ FM-FDE-03 ]
Think Like an FDE III: Agents That Act, Not Chat
This is the doctrine module for operationalizing LLMs in Foundry, and every claim in it is anchored in a lab session we ran and verified. The spine: chat is not the product, acted-on decisions are, and an agent that cannot write back is a search box with manners. The evidence runs both directions. AIP built a correct pipeline from one prompt (FM-PB-01), triaged three escalating notes correctly with a visible token meter (FM-AIP-01), and called its tool when it should while refusing to guess when it should not (FM-AIP-02). It also produced a case-sensitive filter that silently dropped 43 percent of closed rows, then repaired it with a correct condition appended where it could do nothing (FM-PB-02). AIP Assist flatly refuses to execute actions and says so verbatim (FM-ON-02), which fixes the division of labor: the app surface executes, the agent advises. The guardrails are real and checkable: submission criteria and parameter validation as the front door, the dry run as the verification instrument, the Tool description field as the AIP-facing contract, functions as where judgment lives in code. The doctrine that falls out: trust gradients. Read-only suggestions need the least verification, proposed writes need dry runs, autonomous writes need evals and audit trails.