Demo Tuesday - FairPath Learning Demo

Three Demos. Four Learning Stages. One Falling Cost Curve.

This page organizes the exact live progression: Demo 1 solves the task ad hoc, Demo 2A learns it as a prompt skill, Demo 2B tightens that prompt with better information, and Demo 3 materializes the task as ProtoScript code learned in real time. The point is not only that Buffaly answered the question. The point is that it learned how to answer it better, cheaper, and more deterministically over time.

Demo-safe redactionRecovered sessions: 3-30 through 3-30-5Ad hoc -> prompt -> code57.0% lower token cost by code stage
Back to Concepts GalleryJump to Cost Conclusion
Executive summary

One business question, three demos, four learning stages

Buffaly starts by figuring the task out in context. Then it remembers the method as a prompt skill. Then it improves that prompt with better guidance. Finally it turns the method into ProtoScript-backed code. That sequence is what makes the falling token curve meaningful.

Business question: how many patients are ready to be imported for a target office based on the relevant eligibility score logic? Every stage still answers that same operational question. What changes is how much of the method Buffaly has internalized.

Visual takeaway

Cost curve you can show in the room

Demo 1
34,824
Demo 2A
33,024
Demo 2B
19,399
Demo 3
14,965
By the code stage, the primary recorded token count is down 57.0%, while the capability is more reusable and explicit than where it started.
Demo 1

Ad hoc action

Solve the task from scratch and explain the steps.

Recorded tokens34,824 / 313
  1. Buffaly started with the plain-language business question rather than a predefined function.
  2. It explored the real data path, inspected the relevant JSON score structure, and found the actual scoring fields that mattered.
  3. It moved from the initial exploration path to the canonical target and returned the working answer.
  4. This stage proves Buffaly can reason through an unfamiliar operational question in context.
Session: Fairpath Demos 3-30
Demo 2A

Prompt skill learned

Capture the successful ad hoc method as reusable learned behavior.

Recorded tokens33,024 / 249
  1. The ad hoc workflow was turned into a reusable prompt action.
  2. A fresh session could ask the same question and reuse the learned method instead of rediscovering it.
  3. This demonstrates that Buffaly can remember the task in an agent-native form, not just answer it once.
Recovered artifact: ToGetFairPathPatientImportEligibilityGte3CountsByOrganizationSkill
Session: FairPath Demo 3-30-3
Demo 2B

Prompt skill optimized with more information

Improve the learned prompt so it wastes less effort and uses better context.

Recorded tokens19,399 / 167
  1. The learned prompt was refined with more concrete guidance and better target information.
  2. Buffaly corrected the query shape issue that surfaced during refinement and reran the workflow cleanly.
  3. This stage shows that learned behavior can be tuned for efficiency before turning it into code.
Recovered issue: ORDER BY with UNION correction during refinement
Session: FairPath Demo 3-30-4
Demo 3

ProtoScript learned code in real time

Materialize the task as explicit code rather than prompt-only behavior.

Recorded tokens14,965 / 134
  1. The learned task was turned into a deterministic ProtoScript-backed action.
  2. The code path computes thresholded counts directly and emits reusable results, including __TOTAL__.
  3. This stage proves the capability is no longer just remembered text; it has become operational code that can be generalized.
Recovered artifact: ToGetFairPathPatientImportEligibilityGte3CountsByOrganizationDeterministic
Session: FairPath Demo 3-30-5
Paired trust demo

Separate trust demo: HIPAA-safe output

The learning curve above is the main story. Paired with it is a separate trust demo: Buffaly can operate over native patient data and emit only the allowed fields for administrative export instead of flattening protected records into raw LLM text. That means learning speed and data safety can be shown together without mixing the two stories.

Conclusion

Buffaly gets cheaper as the task becomes native

The ad hoc stage is the most exploratory. Prompt learning preserves the workflow. Prompt optimization removes waste. ProtoScript code makes the behavior explicit, reusable, and easier to generalize. That is why the cost drops while the capability gets stronger.
Demo 1 - Ad hoc
34,824 / 313
Demo 2A - Prompt skill
33,024 / 249
Demo 2B - Optimized prompt
19,399 / 167
Demo 3 - ProtoScript code
14,965 / 134
Demo takeaway: Buffaly starts by figuring the task out, then ends by owning the task.

Working concept page built from recovered FairPath demo sessions and redacted for presentation use.