agentic

Files (4)

• SKILL.md
• agentic.moddle.yaml
• local.py
• test_local.py

SKILL.md (first lines)

A model is a pool of its own: a `studyflow:Actor` with no process, named by its `implementation`
(`ollama://gemma4:12b-it-qat`, `claude://claude-haiku-4-5`); the scheme is what makes it this runner's, so the same
pool played by another runner (`simulate://random`) is a one-line change. A step asks it with a message flow to
the pool and one back, and nothing else names a model. `local.py` plays such a pool in a local run: each message
sent to it is one request, and the reply goes back along the pool's flow (`../../packages/runtime-local/CONTRACT.md`, "Messages").

The request is the message's content, in its order. A `Prompt` wired into the asking step gives its text, an image
file in the run or a `data:image/` value goes as an image, and any other value as `<name>: <value>`, the value as text
or, when it is not text, as JSON (`Stimulus: {"Value": "3"}`). The name is that of the element the content's key is (a
property named `instruction`), else the key itself (a field of a Behaverse trial). The runner adds no prompt of its
own. A call that fails answers null, and the run records the error.

A model answers each message on its own, unless its pool's `memory` is `conversation`. Then the runner keeps each
conversation the walk names (one per instance of the pool asking, for the run) and sends it along, turn by turn,
before the new message, so a model answering one subject sees that subject's earlier trials, as sent, and its own
answers to them. A runner started again mid-run has lost them, and fails the message rather than ask without them.
Ollama keeps only the last `num_ctx` tokens of what it is sent, and drops the rest without saying so, so the runner
sends `num_ctx` sized to the conversation: at least 8,192 tokens, in powers of two, estimated generously from the
characters sent, never shrinking for a model within a run (a new size reloads the model), and never past the model's
own context length (`/api/show`), where it fails the message rather than let an earlier turn be dropped. A
conversation that keeps every trial of a long session can need a window of 10^5 tokens, and the memory to hold it.
A pool whose `memory` is `window` is sent the conversation cut to its instructions (the exchanges a prompt delivered
once rode with) and its last `memoryWindow` exchanges (20 unless the actor says), so what it is sent stays the same
size however long the session. The runner keeps the whole conversation, and the record says `memory: window`, the
`window`, and in `sent` how many exchanges it `remembered`.

An `ollama://` model that `/api/show` lists as a `decision` model (d1) writes no text: it returns a probability for
each answer it is offered. The runner asks it `/v1/systemone` one choice question, the message's text as the
question's instructions and the answers the message lists under `ResponseOptions` as its criteria, with the message's
images; a message that lists none fails, since there is nothing to choose among. In a conversation the model, which
keeps no state between requests, receives what its pool remembers of the conversation (all of it, or its window) as
its `state` with every message. Ollama serves the model with a window of its own (its `num_ctx`, else its context
length) that a request cannot raise, so a state past it loses its oldest exchanges first, never the instructions' nor
the message itself, and the record says how many exchanges it `kept` and, when it dropped one, `truncated: true`; a
message that does not fit with its instructions alone fails. The runner draws
the answer from the probabilities with a seed keyed by the study, the participant (who asks) and the trial (how many
messages that participant had sent the pool before), whatever the pool remembers, so a re-run draws the same answers
whatever ids a task gives its messages, and the record keeps the
`probabilities`, the model's own most probable `choice` and `confidence`, and the `draw` (its key and the uniform `u`).
Every Ollama record says which `kind` the model is, `chat` or `decision`.

Each answer comes back with a `record`, which joins the step's record and is never a value a step reads
(`../../packages/runtime-local/CONTRACT.md`, "What comes back"). From Ollama: the model, its digest and quantization level (`/api/tags`),
its default sampling parameters and context length (`/api/show`), Ollama's version (`/api/version`), the options this
runner sends (`think: false`, `stream: false`, and `num_ctx`), the tokens the request was estimated to need
(`contextEstimate`) and those Ollama evaluated for it (`promptTokens`). From Claude: the model asked for, the model the response names, and
`max_tokens`. From both, `sent`: the request's text as sent, up to 4,000 characters, how many images went with it, and
in a conversation its `turn`. The lookups are best effort: one that fails is noted under `unrecorded`, and the answer stands.
`test_local.py` is its self-check.

From behaverse/studyflow-modeler, MIT.

More from behaverse/studyflow-modeler