Most conversational analytics ask what was said. This asks how the exchange actually went — who produced language, who waited on whom, who initiated and who responded, where meaning was repaired, and how influence moved between human and artificial participants. Chat applications post contributions as they happen and read back a continuously updated analysis over the same API.
The system is an implementation of existing traditions in the study of talk, not a new theory of conversation. Each commitment below shows up as a specific decision in the code — that traceability is the point.
repairRate alongside act-to-act transition matrices. Adjacent-turn latency
is measured between human turns rather than averaged over everything.not_applicable rather than a curve.TypeScript on Node, Express, and Google Cloud primitives. One container image serves two roles; a role variable decides which route groups mount.
Runs for every valid thread with no external calls and returns inside the ingest response: production ratios, lexical density and diversity, timing (time-to-first-token, generation duration, end-to-end, per-output-token, human adjacent-turn latency), speech-act structure, repair and acceptance rates, participation balance and an early/middle/late trajectory.
LCC produces learner curves across four quadrants — relevant/new, relevant/old, irrelevant/new, irrelevant/old — against a versioned reference model. ICCC produces six per-participant curves against the discussion itself. They share a semantic kernel but stay theoretically distinct: there is no merged score anywhere in the system.
No database. Versioned JSON objects in Google Cloud Storage, with optimistic concurrency through generation preconditions and retry. The in-memory implementation reproduces the same semantics, so tests exercise production code paths rather than a stub.
Ingestion is synchronous; analysis is not. Speech-act and semantic work is queued, and 16
event types stream to subscribers over Server-Sent Events with replay-on-reconnect via
Last-Event-ID.
Configuration refuses to start a production deployment with an in-memory repository, a process-local queue or event bus, or mock authentication. The context builder refuses the same combinations as a second line of defence.
Structured output is obtained through one schema-constrained tool call, behind a single gateway with an automatic fallback provider. Model capability differences — such as newer Claude models rejecting sampling parameters — are handled at that chokepoint.
Raw text, tokens and credentials never reach operational logs — a redactor is the single chokepoint. xAPI statements carry pseudonymous actors and no conversation text. Research reads are scope-filtered and pseudonymised at the projection boundary.
Every request body, query and parameter is schema-validated before any repository call. Identifiers are opaque by pattern, so personal data cannot ride in an id.
Your chat app posts one completed message, with the timings it captured while streaming.
Deterministic measures are computed in-request and returned with the response.
Speech-act classification and any enabled semantic work are enqueued as jobs.
The worker classifies, runs the engines, and persists versioned analysis envelopes.
Results publish to subscribers as events; provisional values announce their own revision.
| Surface | What it is |
|---|---|
| Ingestion | One completed message per call, or up to 500 in an ordered batch. Idempotent on thread + turn id. |
| Interaction types | 5 — from general dyad through group tutoring; the type gates which engines can apply. |
| Speaker types | 6 — human, assistant, agent, avatar, system, tool. |
| Roles | 4 — data owner, researcher, application client, system administrator. |
| Research scopes | 15 scoped permissions on a revocable, audited grant. |
| Quality flags | 31 codes explaining why a value is null, partial or approximate. |
Anywhere a conversation between people and machines is worth understanding as an interaction — and where the honest answer sometimes has to be "not measurable here".
Instrument a live assistant and see how the exchange behaves: how much of the language the model produces, how long people wait, how often the conversation needs repair, and how that shifts when you change a prompt or a model.
With an authored reference model, LCC tracks how a designated learner's contributions distribute across relevance and novelty over a session — reported as curves against an external model, never as a mastery score.
ICCC treats every participant — human, assistant or agent — under the same six measures, which makes mixed human/agent discussions directly comparable without special-casing who is a person.
Scoped, revocable, audited grants give researchers pseudonymised access to exactly the fields their consent covers, with exports in JSON, JSONL or CSV and an access history the owner can inspect.
Because measures are computed per turn with provenance attached, the same thread can be compared across models or prompt versions on interaction shape rather than on a single preference score.
Consent versions ride on threads and participants, deletion is explicit, and the interface that demonstrates the system contains no analytical implementation of its own — it can only show what the API returned.
These are mechanisms the design produces — consequences of how the system is built. They are not study results, adoption figures or efficacy claims, and nothing here has been measured in the field.
Turn-level timing, production ratios and repair rates give a conversation quality vocabulary that does not depend on collecting user ratings. Because ingestion is idempotent and off the render path, adding it cannot degrade the chat it observes.
Preconditions are enforced rather than assumed: an interaction that does not qualify for
LCC returns not_applicable with reasons. The system's refusal to produce a number
is itself a result, which makes over-claiming harder than under-claiming.
Every value carries its algorithm version, semantic model version, source content hash and quality flags. A figure in a paper can be traced to the code path and inputs that produced it, and reanalysis is versioned rather than destructive.
Delegation is enforced in the token, grants are scoped and revocable, and access is audited including denials. The owner can export their complete archive. None of this depends on an application choosing to behave well.
Production refuses to start on an unsafe configuration rather than degrading quietly. Where analysis genuinely cannot complete, the result is a flagged null, not a fabricated zero that would corrupt every average computed downstream.
Keeping LCC and ICCC computationally separate resists the temptation to publish a single "collaboration score". Two theories that answer different questions stay two numbers, which is harder to misuse than one.