# Asking several questions at once

> given().ask({...}) sends independent Noul, Score, and Choice questions about one subject in one request.

When several independent things need judging about one subject, `given(x).ask({ ... })` asks them together. They share a request until the runtime’s batching limit is reached; each key comes back as its own `Judgment`.

```ts
import { chooseFrom, given, means, scale } from "jevlish";


interface Feedback {
  text: string;
  plan: "free" | "pro" | "team";
}


const AREAS = ["invoicing", "reports", "exports", "permissions"] as const;


const severity = scale<Feedback>("how badly the problem affects the user")
  .from("An annoyance; work continues")
  .through("Work continues through a workaround")
  .to("The user cannot do their job");


const profile = (item: Feedback) =>
  given(item)
    .seenAs((f) => ({ message: f.text }))
    .ask({
      problem: means<Feedback>("the message describes something not working"), // Noul
      request: "the user asks for a change or a new capability", // Noul, from a string
      severity, // Score over three described levels
      area: chooseFrom(AREAS).by("which part of the product the message is mainly about").orNone("no single area"), // Choice
      paying: (f) => f.plan !== "free", // code; adds nothing to the request
    });


const answers = await profile({ text: "Exports hang every Friday. We copy the data by hand.", plan: "team" });


answers.problem; // Judgment<boolean>
answers.severity; // Judgment<Measurement>
answers.area; // Judgment<"invoicing" | "reports" | "exports" | "permissions" | null>
answers.paying; // Judgment<boolean>, decided by code
answers.problem.evidence === answers.area.evidence; // every answer shares one request
```

## What can be asked

Each value in the object is one of:

* A **condition**: a string, a code predicate, or a meaning. Produces `Judgment<boolean>`. Composite meanings are fine; their semantic leaves become separate Noul questions in the same request and are combined locally.
* A **scale**. Produces `Judgment<Measurement>`.
* A **Choice**: `chooseFrom(candidates).by(criterion)`, optionally `.orNone(...)`. Produces `Judgment<C>` or `Judgment<C | null>`.

The result type is inferred per key, so `answers.severity.value` is a `Measurement` and `answers.area.value` is one of the `AREAS`.

## Code predicates cost nothing

A predicate in the object is evaluated locally and recorded as a `code` judgment. It adds nothing to the request. `paying: (f) => f.plan !== "free"` is there so the answer sits next to the others with the same shape, not because the model is consulted.

If every question is settled by code, no request is sent at all.

## Shared evidence

All answers from one `ask` share the same `evidence` object: the one request, every judgment, and the policy. Checking `answers.problem.evidence === answers.area.evidence` is true. This is what makes it possible to count intersections afterwards, as the [Insights example](/Jevlish/examples/insights/) does, knowing they came from the same look at the same message.

## Batching

A runtime splits a question set into requests of at most `questionsPerRequest` (default 32) and caches each chunk independently. A large `ask` may therefore become more than one request; `plan()` shows how many. See [Runtime](/Jevlish/guides/runtime/).