Skip to content

Instantly share code, notes, and snippets.

@jrecursive
Created September 1, 2026 12:46
Show Gist options
  • Select an option

  • Save jrecursive/fe4e121d8de7827e32f0123401a6e088 to your computer and use it in GitHub Desktop.

Select an option

Save jrecursive/fe4e121d8de7827e32f0123401a6e088 to your computer and use it in GitHub Desktop.

Use the Culture MCP experiment tools to run a 10-case Luna study of circuit synthesis from ordinary business-owner natural language.

The purpose of this study is to test whether Luna can take realistic, underspecified process descriptions from nontechnical users and infer a sensible persistent circuit architecture.

These prompts intentionally do NOT specify:

  • message types;
  • terminals;
  • device kinds;
  • state machines;
  • joins;
  • queues;
  • gates;
  • timers;
  • deduplication;
  • inference nodes;
  • persistence mechanisms;
  • implementation details.

Do not rewrite the prompts into technical specifications before submitting them.

Evaluate what Luna itself infers from the natural-language request.

Setup

First inspect Culture read-only state and resolve the exact persisted IDs for:

  • the current Luna model configuration used for logical planner experiments;
  • PLANNER_5, or the newest installed planner lineage if that exact lineage is unavailable;
  • the logical-2 schema.

Use exact persisted IDs. Do not guess them.

Use the same:

  • Luna model configuration;
  • planner lineage;
  • logical-2 schema;
  • turn timeout;

for all ten cases.

Use:

wait_mode = "accepted"
turn_timeout_seconds = 600

for every experiment.

Use a unique descriptive idempotency key for every case.

Launch experiments only through the controlled Culture experiment MCP tools.

Do not use SQL, direct HTTP, database mutation, or other backdoors to launch or continue experiments.

Do not use experiment_continue during this study.


Execution strategy

Phase 1 — submit all ten

Submit all ten Luna experiments in accepted mode before beginning sustained polling so independent syntheses can run concurrently.

For every successful admission, retain:

case_id
conversation_id
turn_id
initial_status
retry_after_ms

Surface a compact mapping from case ID to conversation ID at the earliest host-supported opportunity.

Preserve these IDs throughout the study.

If observation later fails, do not relaunch the experiment merely because you temporarily cannot inspect it.

Phase 2 — wait for all syntheses

Poll nonterminal experiments using:

experiment_get(
    conversation_id=<conversation_id>,
    limit=1
)

Do not supply pagination cursors.

Follow each experiment's advisory retry_after_ms approximately.

Interleave observation across the ten experiments intelligently.

Do not tight-loop.

Continue until all ten experiments are terminal or one is demonstrably unrecoverable.

Polling is observation only and must not be treated as driving execution.

Phase 3 — inspect every output

For every completed experiment, inspect the full Luna synthesis and persisted experiment evidence.

Do not repair, reinterpret, or modify Luna's circuit before evaluating it.

Schema validation is necessary evidence, but valid=true does not imply semantic correctness.

Phase 4 — synthesize a report

Only after all ten cases have been inspected, produce a comparative report.


Natural-language business cases

Submit the following text as the actual planner prompt for each corresponding experiment.

Do not prepend a technical translation of it.


CASE 1 — Dental office front desk

I run a dental office with two dentists, three hygienists, and a couple of people at the front desk. I want something that helps us keep appointment requests, cancellations, reminders, insurance questions, and people who need to be called back from falling through the cracks.

If somebody cancels, I'd like us to have a reasonable way to offer the opening to people who are waiting for an earlier appointment, but I don't want patients getting a bunch of duplicate texts or two people being promised the same opening.

Some things can happen automatically, like routine reminders, but anything unusual involving insurance, an upset patient, or a treatment question should end up with a person.

I'd like the staff to be able to see what still needs attention without maintaining three different lists by hand.


CASE 2 — Small property-management company

We manage about 80 rental units for different owners. I'd like to organize maintenance requests so tenants aren't constantly calling us to ask whether anyone saw their message.

Requests come in by email, web form, and sometimes somebody at the office enters one from a phone call. We need to figure out what the problem is, whether it's urgent, which property it's for, and whether it should go to our handyman or an outside vendor.

Emergencies like no heat in winter or a major leak shouldn't sit around waiting for normal office hours. Routine things can.

We also need to keep track of whether somebody was assigned, whether the tenant has been contacted, whether the repair actually happened, and whether we're waiting on the owner to approve an expensive repair.

I mainly want one place where nothing quietly disappears.


CASE 3 — Catering company

We do catering for weddings, company events, and private parties. An inquiry usually starts with a date and rough guest count, then turns into a bunch of emails about menu choices, allergies, rentals, staffing, delivery, changes, deposits, and the final headcount.

I'd like something that keeps each event organized from the first inquiry through the event being finished.

We shouldn't accept two events if we don't actually have the staff or kitchen capacity to handle both. Changes close to the event are especially important because somebody needs to notice them.

We also need to make sure deposits and final payments are followed up on without annoying people who have already paid.

Anything involving unusual dietary requirements, a big pricing exception, or a customer who seems unhappy should get a person involved.


CASE 4 — Auto repair shop

I own an independent auto repair shop. Customers call, text, or use our website to ask for service. Cars come in, somebody diagnoses them, we put together an estimate, the customer approves some or all of it, parts may need to be ordered, the work gets done, and then the customer needs to know when the car is ready.

I'd like to make that whole process easier to keep track of.

I especially want to avoid starting work that wasn't approved, forgetting that we're waiting for a part, or telling a customer their car is ready when something is still unfinished.

If an estimate changes a lot after the customer approved it, somebody should contact them again.

Routine status messages are fine to automate, but questions about whether a repair is actually necessary should go to a technician or service advisor.


CASE 5 — Residential cleaning company

We have a residential cleaning company with several crews. Some customers are weekly or every other week, some book one-time cleanings, and people reschedule all the time.

I'd like a system that keeps track of the jobs that need to happen, which crew is doing them, special customer instructions, keys or access information, and anything the crew reports afterward.

If somebody cancels or moves a visit, I don't want the old visit to somehow stay on somebody's schedule.

If a cleaner reports damage, couldn't get into the house, or says the job was much bigger than expected, the office needs to know right away.

At the end of the day I'd like to know what got done, what didn't, and what still needs somebody to follow up.


CASE 6 — Custom cabinet shop

We build custom cabinets for homeowners and contractors. A job starts with drawings and measurements, then there are material choices, quotes, customer approvals, ordering materials, shop work, finishing, delivery, and installation.

There are a lot of places where an old drawing or an old measurement can cause a very expensive mistake.

I'd like something that keeps the current version of the job clear and makes sure people aren't building from something that has already been replaced.

Some jobs also get held up waiting for the customer, an architect, hardware, or a special-order material.

I want the shop to be able to tell what is actually ready to work on and what is blocked, without somebody walking around asking everyone.


CASE 7 — Veterinary clinic

We have a veterinary clinic and get messages all day from people asking about appointments, medication refills, test results, food, behavior problems, and pets that may be sick.

I'd like the routine administrative stuff organized automatically so the staff isn't constantly sorting the inbox.

Medication refill requests should not just get approved automatically because somebody needs to make sure the pet is actually eligible for the refill.

Anything that sounds medically urgent should get noticed quickly, even if the owner didn't use the right words.

When lab results come back, they need to end up attached to the right patient and the right outstanding issue so we don't have somebody calling about a result that nobody can find.

I don't want an AI answering medical questions on its own. I mostly want it to help us sort, summarize, and make sure the right person sees things.


CASE 8 — Event venue

We rent out a venue for weddings, parties, nonprofit events, and business events. People ask whether dates are available, then they may tour the venue, ask for a quote, put a date on hold, sign a contract, pay deposits, make changes, and eventually have the event.

I'd like to stop managing all of this through a shared inbox and a giant spreadsheet.

We absolutely cannot accidentally promise the same date to two customers.

A temporary hold should expire if somebody never follows through, but a signed contract should obviously not disappear just because time passed.

As the event gets closer there are things we need from the customer, like final guest count, vendor information, setup plans, and final payment.

I'd like the staff to know what needs attention without manually reviewing every event every morning.


CASE 9 — Commercial HVAC service company

We service heating and cooling systems for small businesses and apartment buildings. Customers call us when something breaks, but we also have maintenance contracts where we're supposed to inspect equipment on a schedule.

I'd like one workflow for incoming service calls and planned maintenance.

If a restaurant's walk-in cooler is down or an apartment building has no heat, that should obviously be treated differently from a routine filter change.

Sometimes a technician can't finish because a part needs to be ordered, the customer needs to approve a larger repair, or another technician with different skills has to come back.

I want us to keep following the job until it is actually resolved rather than treating the first technician visit as the end of it.

Customers should get useful updates, but I don't want them getting the same notification every time somebody updates an internal note.


CASE 10 — Small bookkeeping firm

We do monthly bookkeeping for about 40 small businesses. Every month we need statements and other documents from clients, then we reconcile accounts, ask questions about transactions we don't understand, make corrections, and eventually close the month and send the client their reports.

The annoying part is chasing missing documents and remembering which questions are still waiting for answers.

I'd like something that can keep each client and month organized, notice what is still missing, and remind people without sending the same request over and over.

If a client sends a document later, it should obviously stop being considered missing.

Some transactions are easy to categorize, but ambiguous or unusual ones should be put in front of a bookkeeper rather than guessed.

I also don't want a month marked complete while there are still unresolved questions or unreconciled accounts.


Evaluation methodology

This study is particularly interested in what Luna infers from ordinary language.

For every case, capture at least:

case_id
conversation_id
turn_id
final_status
elapsed_ms
schema_valid
provider invocation count
provider attempt count
terminal/device count
inference-node count

Then inspect the synthesis using the following rubric.

A. User-intent fidelity

Ask:

If the business owner who wrote the prompt saw this circuit, would they recognize it as solving the problem they described?

Identify:

  • requirements Luna clearly understood;
  • requirements it missed;
  • requirements it distorted;
  • requirements it invented;
  • places where ambiguity was handled sensibly;
  • places where Luna made an unjustified assumption.

This is the most important category in this study.

B. Implicit state inference

Determine whether Luna correctly inferred persistent business state even though the user never asked for "state."

Examples include:

  • appointments;
  • jobs;
  • cases;
  • outstanding questions;
  • customer approvals;
  • holds;
  • versions;
  • payments;
  • assignments;
  • waiting conditions;
  • unresolved exceptions.

Identify where Luna correctly inferred lifecycle/state ownership and where it treated a persistent process as stateless message routing.

C. Identity, correlation, and duplicate handling

Look for situations where an ordinary business request implicitly requires identity and correlation.

Evaluate whether Luna inferred things such as:

  • patient/customer/job/event/property/client identity;
  • matching later updates to earlier work;
  • retry/duplicate suppression;
  • avoiding duplicate notifications;
  • avoiding double booking;
  • avoiding repeated work.

Do not require a particular implementation, but assess whether the resulting semantics are safe.

D. Lifecycle modeling

Determine whether Luna inferred meaningful lifecycle states from prose.

Examples:

requested
scheduled
waiting
approved
blocked
in progress
completed
cancelled
expired
superseded

Assess whether the circuit keeps a process alive until the business meaning of "done" is actually satisfied.

E. Human versus automatic work

Evaluate whether Luna makes sensible decisions about:

  • what can be deterministic;
  • what benefits from semantic inference;
  • what should be prepared automatically but approved by a person;
  • what should remain explicitly human-controlled.

Pay particular attention to the dental, veterinary, auto-repair, and bookkeeping cases.

Flag unsafe or unnecessary autonomous decisions.

F. Exception handling

Business owners frequently describe the happy path and mention only a few exceptions.

Evaluate whether Luna gives exceptions durable representation rather than allowing them to disappear.

Look for:

  • escalations;
  • blocked work;
  • unresolved conditions;
  • stale versions;
  • approval waits;
  • failed access;
  • missing documents;
  • emergencies;
  • unusual cases.

G. Time semantics

Where relevant, inspect whether Luna inferred:

  • deadlines;
  • expiration;
  • reminders;
  • business hours;
  • scheduled maintenance;
  • follow-up;
  • waiting;
  • overdue work.

Flag places where a timer or temporal condition is clearly implied but absent.

H. Resource/capacity semantics

Several prompts imply scarce resources:

  • dental openings;
  • catering capacity;
  • cleaning crews;
  • venue dates;
  • technicians.

Determine whether Luna recognizes these as constraints requiring state and coordination rather than ordinary routing.

Do not require Luna to build an optimization solver unless the task warrants one.

Assess whether its representation would prevent obvious conflicts.

I. Deterministic versus inference boundaries

Record every model/inference device and its purpose.

Classify each as:

well justified
arguable
probably unnecessary
unsafe/inappropriate

Look for recurring inference roles across businesses.

J. Circuit complexity

Record:

  • number of input/output terminals;
  • total devices/operators;
  • persistent components;
  • model components;
  • major forks/joins/gates/timers/queues/state managers.

Judge the result as:

underbuilt
appropriately sized
overbuilt

Explain why.

The prompts are intentionally vague enough that maximum device count is not a measure of success.

K. Tacit requirement inference

This is another major focus.

Identify useful requirements Luna inferred even though the owner did not state them explicitly.

Examples might include:

  • deduplicating an intake channel;
  • rejecting stale approvals;
  • retaining audit history;
  • correlating delayed results;
  • separating a temporary hold from a confirmed booking;
  • distinguishing an internal status update from a customer notification.

Also identify tacit requirements Luna should have inferred but failed to.

Do not reward arbitrary feature invention.

The distinction is:

reasonable consequence of the user's business rules
vs.
unprompted product design

Cross-case report

After all ten syntheses are terminal and inspected, produce a detailed comparative report.

1. Executive summary

Answer:

How well can Luna translate ordinary business-process language into a coherent logical circuit without the user understanding the circuit model?

Discuss:

  • overall reliability;
  • strongest capabilities;
  • weakest capabilities;
  • whether the abstraction appears usable by nontechnical users.

2. Results table

One row per case:

Case Business/process Status Schema valid Devices Inference nodes Elapsed Intent fidelity

Use concise ratings such as:

excellent
good
mixed
poor

but support them in the case analysis.

3. Case-by-case analysis

For every case:

  • summarize Luna's architecture;
  • explain what business process it inferred;
  • identify strong decisions;
  • identify defects;
  • identify reasonable tacit requirements it inferred;
  • identify tacit requirements it missed;
  • judge whether a real business owner would likely find the behavior recognizable.

4. Natural-language interpretation patterns

Across all ten cases, identify concepts Luna consistently maps correctly from ordinary language.

For example:

"don't let this fall through the cracks"
"don't send it twice"
"waiting for approval"
"someone needs to look at this"
"don't promise the same thing to two people"
"keep following it until it's actually done"
"the old version shouldn't be used"

Report what circuit structures Luna actually derives from such language.

5. Implicit primitive matrix

Based on the resulting circuits, construct a matrix of which business-language cases caused Luna to synthesize:

persistent state
deduplication
correlation/join
queue/backlog
gate
timer
expiration
watch/change detection
resource reservation
version/supersession handling
human approval
exception stream
inference classification
inference summarization
parallel inference
business-hours logic
feedback/retry
completion/readiness checks

This is based on actual outputs, not merely what the prompts appear to request.

6. Missing-tacit-knowledge analysis

Identify the most important things a technically knowledgeable workflow designer would know must exist, but a normal business owner would probably omit.

Then determine how often Luna supplied those things correctly.

Examples may include:

  • stable identity;
  • idempotency;
  • durable state;
  • lifecycle ownership;
  • correlation;
  • stale-result handling;
  • reservation/conflict prevention;
  • explicit unresolved state;
  • readiness conditions.

This section is especially important.

7. Over-inference analysis

Identify where Luna goes beyond reasonable inference and invents:

  • unnecessary workflow stages;
  • unsupported business policies;
  • excessive automation;
  • gratuitous model calls;
  • overly elaborate machinery.

We want a planner that fills in engineering necessities, not one that invents the customer's business.

8. Inference-node analysis

Across all ten cases:

  • count inference nodes;
  • categorize their roles;
  • identify repeated patterns;
  • judge whether semantic work is separated cleanly from deterministic bookkeeping.

Identify any recurring model-node patterns that might deserve reusable templates or first-class runtime support.

9. Complexity behavior

Compare prompt/business complexity with synthesized circuit size.

Report:

  • min device count;
  • max device count;
  • median;
  • mean;
  • obvious outliers.

Discuss whether Luna tends to underbuild or overbuild when requirements are expressed informally.

10. Synthesis runtime

Report:

  • minimum elapsed time;
  • maximum;
  • median;
  • mean.

Look cautiously for relationships between:

  • prompt ambiguity;
  • resulting device count;
  • inference-node count;
  • synthesis latency.

Do not overinterpret ten observations.

11. Nontechnical-user viability

Give a focused assessment of the product hypothesis:

Could a normal business user plausibly describe a problem in everyday language and get a useful circuit without learning the underlying circuit vocabulary?

Separate:

Already plausible

Things Luna handles reliably enough that the UI could largely hide the underlying system.

Needs confirmation

Things Luna appears to infer correctly but would benefit from a user-visible confirmation step.

Too risky to infer silently

Things where the system should probably ask the user, expose the assumption, or require approval.

Too technical for current planner behavior

Areas where ordinary prose does not give Luna enough structure yet.

12. Opportunities for compiler/runtime assistance

Identify mistakes that should not necessarily be solved by making Luna smarter.

Look for things a downstream compiler, validator, linter, optimizer, or runtime could detect or enforce automatically, such as:

  • missing deduplication around retriable inputs;
  • unsafe stale-result acceptance;
  • state without clear ownership;
  • missing loop bounds;
  • conflicting reservations;
  • unreachable outputs;
  • model calls used for deterministic work;
  • missing terminal/readiness conditions.

Distinguish planner problems from problems better solved mechanically.

13. Candidate UX implications

Based on the ten results, identify what a natural-language circuit-building UI might need to show the user after synthesis.

For example, perhaps the system should summarize:

What I understood
What I will automate
What still requires a person
What I will remember
What can block a case
What I assumed

Do not design a full UI unless the findings justify it.

Focus on what the experiments reveal users may need to confirm.

14. Regression candidates

Choose the strongest subset of these ten cases for a future natural-language regression suite.

Explain what each selected case uniquely tests.

15. Next experiments

Recommend the next study after this one.

Consider possibilities such as:

  • rerunning the same prompts through Terra;
  • deliberately making prompts even shorter;
  • ambiguous/conflicting business requests;
  • iterative user corrections;
  • comparing expert specification against ordinary-language specification;
  • measuring whether a model can explain its synthesized circuit back to the business owner.

Choose recommendations based on observed results rather than assuming them in advance.

16. Overall conclusion

Answer concretely:

What does this study tell us about using Luna as the translation layer between an ordinary person's description of work and Culture's circuit model?


Orchestration and recovery requirements

Throughout the entire study:

  • preserve all ten conversation IDs;
  • preserve each original idempotency key;
  • do not relaunch cases because polling fails;
  • do not alter Luna's output before evaluation;
  • do not continue experiments;
  • do not technically elaborate the natural-language prompts before submission;
  • distinguish canonical experiment failure from inability to observe;
  • use conversation_id for ordinary recovery after successful admission.

At the end include an appendix:

Case Conversation ID Turn ID Final status Elapsed

so every synthesis can be revisited later.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment