Make AI-Generated Calculators Explain Their Inputs

OpenAI's October 7 announcement of GPT-6 and Intelligent UI describes ChatGPT responses that can include forms, charts, buttons and interactive tools. It also describes native components that appear progressively as the model generates an interface.

That makes a familiar engineering question more visible: what calculation sits behind a convenient control?

My interpretation is that developers should make the inputs, assumptions and result easy to inspect when building similar tools. This article uses a deliberately small capacity calculator to show what that means. It is a hypothetical example, not an implementation of OpenAI's component system or evidence that a generated ChatGPT tool has passed these checks.

Write down the calculation first

Suppose a support team wants a rough monthly capacity estimate. The model has three inputs:

• Monthly request count.
• Average minutes spent per request.
• Productive support minutes available per person in that same month.

Multiplying the first two gives workload minutes. Dividing that by productive minutes per person gives a fractional staffing estimate. Rounding upward produces a whole-person capacity estimate.

Every part of that description matters. Scheduled work hours and productive support minutes are different inputs. Monthly averages leave out peak-hour coverage. A single average handling time hides variation between simple requests and specialist work.

The interface should state these limits near the result. They are assumptions to review with someone who knows the work. A correct division cannot tell you whether the three-input model represents the team's actual staffing constraints.

Keep one deterministic calculation

A small pure function is enough for this example. Given the same inputs, it returns the same result and changes no external system. The generated interface can call it when an input changes.

Here is a complete JavaScript example:

export function estimateCapacity(input = {}) {
  const fields = [
    "monthly_requests",
    "average_minutes_per_request",
    "monthly_productive_minutes_per_person",
  ];
  const missing = fields.filter((key) => input[key] === undefined);
  if (missing.length) return { status: "needs_input", fields: missing };

  const invalid = fields.filter((key) =>
    typeof input[key] !== "number" || !Number.isFinite(input[key])
  );
  if (!Number.isInteger(input.monthly_requests) || input.monthly_requests < 0)
    invalid.push("monthly_requests");
  if (input.average_minutes_per_request <= 0)
    invalid.push("average_minutes_per_request");
  if (input.monthly_productive_minutes_per_person <= 0)
    invalid.push("monthly_productive_minutes_per_person");
  if (invalid.length)
    return { status: "invalid_input", fields: [...new Set(invalid)] };

  const workload = input.monthly_requests * input.average_minutes_per_request;
  const people = workload / input.monthly_productive_minutes_per_person;
  if (!Number.isFinite(workload) || !Number.isFinite(people))
    return { status: "invalid_input", fields };

  return {
    status: "ok",
    formula_version: "monthly-capacity-v1",
    workload_minutes: workload,
    fractional_people: people,
    rounded_people: Math.ceil(people),
  };
}

For the demonstration, pass an object containing numbers. Convert form strings deliberately before calling the function, and preserve an empty field as missing; Number("") produces zero and can hide an omitted value. A real endpoint also needs to validate the shape of its incoming object before using this function.

The function rejects invalid numbers and nonpositive time values. It returns a separate needs_input state when a required value is absent. Display that state as a request for information, keeping any previous result clearly marked as stale.

No model call is required to redo the arithmetic. If the formula changes, review the change and update its version so a saved result can be interpreted later.

Check the boundaries that change the answer

Use known results to check the function before connecting an interface. These checks run in Node alongside the example:

import assert from "node:assert/strict";

const sample = {
  monthly_requests: 800,
  average_minutes_per_request: 12,
  monthly_productive_minutes_per_person: 4800,
};
assert.equal(estimateCapacity(sample).fractional_people, 2);
assert.equal(estimateCapacity({ ...sample, monthly_requests: 0 }).rounded_people, 0);
assert.equal(estimateCapacity({}).status, "needs_input");
assert.equal(estimateCapacity({ ...sample, monthly_requests: -1 }).status, "invalid_input");
assert.equal(estimateCapacity({ ...sample, monthly_requests: "800" }).status, "invalid_input");
assert.equal(estimateCapacity({ ...sample, monthly_productive_minutes_per_person: 0 }).status, "invalid_input");

All numbers here are synthetic demonstration inputs. They make the arithmetic observable and carry no staffing recommendation.

Then check the interface itself. Clearing an input should request information. Changing the request count should use the new value. Each label should show its unit and period. If the display rounds a result, the unrounded value and rounding rule should remain available.

An exported summary should contain the inputs, formula version, result and omitted factors. Another person should be able to reproduce it with ordinary arithmetic. This also helps reveal when a result was calculated using an earlier set of inputs.

Give external actions their own review

A calculator control can adjust a scenario locally. Submitting a staffing request is a separate operation that writes a record and may start an approval process.

If you later add that operation, show the destination and proposed payload, check authorization on the server, and confirm the resulting record. Handle an uncertain response by checking whether the record already exists before resubmitting. The interface's own input validation does not establish permission to write.

The OpenAI announcement does not show that every interactive answer can perform such external actions. These are implementation responsibilities for a system you choose to connect.

Start with a calculation you can inspect

The announcement says Intelligent UI is rolling out in ChatGPT's Chat experience; enterprise availability depends on admin settings. It does not introduce this example as an API or change the models powering Work and Codex as part of the release.

For your own prototype, choose a familiar calculation, state its assumptions, use synthetic inputs, and keep it limited to scenario exploration initially. Ask a domain expert whether the omitted factors change the decision.

A useful generated interface makes the calculation understandable, lets people correct its inputs, and tells them when it cannot produce a meaningful result. Those properties can be checked regardless of how impressive the first rendering looks.