Blame for README.md

---
pretty_name: AI Service QoS — field evidence for a Qwen3.8-Max / Qoder CN incident
tags:
  - ai-evaluation
  - observability
  - reliability
  - latency
  - large-language-models
  - service-quality
size_categories:
  - n<1K
language:
  - en
license:
  - cc-by-4.0          # documented key is `license` (accepts a list); `licenses` is ignored
configs:
  - config_name: request_lifecycle_round1
    data_files:
      - split: train
        path: evidence/stats/request_lifecycle.csv
    default: true
  - config_name: request_lifecycle_round2
    data_files:
      - split: train
        path: evidence/incident_20260910/request_lifecycle.csv
  - config_name: session_sizes
    data_files:
      - split: train
        path: evidence/stats/session_size_stats.csv
  - config_name: context_growth
    data_files:
      - split: train
        path: evidence/stats/context_growth.csv
  - config_name: timeline_events
    data_files:
      - split: train
        path: evidence/stats/timeline_events.csv
  - config_name: timeout_events
    data_files:
      - split: train
        path: evidence/logs/timeout_resume_events.csv
---

> **Released 2026-09-11 as v1.0.2** (methodology v0.1). This snapshot is frozen: later
> corrections and additions ship as a new version with a new tag, never as an edit to the bytes a
> citation points at — cite the tag or the Digital Object Identifier, not a branch. Two version
> numbers mean two different things here: the tag names this public snapshot, while *methodology
> v0.1* names the definitions, which stay unchanged until a second provider has been measured
> (section 7). Every figure quoted in this document set is asserted against the shipped evidence by
> `scripts/analyze.py`, which fails when a number and the evidence disagree and warns when a file
> is edited after the date above.

**AI Service QoS — Independent Measurement of What Users Actually Receive** — methodology v0.1, and the first data product of an independent, outside-in measurement framework. The system measured here is **Case Study 1**, not the subject: the framework claims provider neutrality and one provider is not proof of it — a second provider measured with *these same definitions and no new ones* is the test (paper section 7, Stage 3).

Machine-checkable evidence for **"AI Service QoS: An Independent Outside-In Measurement Methodology, with Case Study 1 (Qwen3.8-Max / Qoder)"** (`paper_ai_QoS.md`, with the practitioner report
`report_qwenAliServiceQuality.md`). It is a request-level measurement of the
service quality an ordinary user experiences in an artificial-intelligence coding
service, taken entirely from the client's own runtime log, with no provider
cooperation and no access to the provider's infrastructure.

## Dataset details
### Where each layer of this project lives

This repository is the **data layer**. The method document (`paper_ai_QoS.md`) and
**Case Study 1** (`report_qwenAliServiceQuality.md`), the vendor-facing report with the
per-event tables and the asks, are in the source repository:
<https://github.com/2makeitwork/paper_ai_Qos> — together with the collector, the
anonymiser and the log mirror that produced these files. Two scripts ship **here** as
well, so that nothing in this card has to be taken on trust inside this repository:
`scripts/analyze.py` re-derives and asserts every published figure against `evidence/`,
and `scripts/verify_dataset_card.py` asserts this card against the files it declares.


### Motivation

Capability benchmarks score answers; provider dashboards report what the provider
chooses to measure. Neither answers the user's question — *did my request get a
usable answer, and how long did I wait?* This dataset exists so that question can
be asked of a service from the outside, and so every number in the paper can be
recomputed from these files rather than taken on trust.

### Verification after publication

The whole published repository was downloaded back into an empty directory and compared file by
file with the tag it was built from — which is exactly what `scripts/check_release_sync.py` does,
so this is re-checkable by a reader rather than autobiographical. Measured 2026-09-11 against tag
`v1.0.2`: **every data-layer file agrees byte for byte**, `README.md` included — that file
is this card with its three internal-instruction lines removed, and the source repository's own
`README.md` is a different document, its homepage. The hub holds one file no tag contains: the
`.gitattributes` it created with the repository. The generated table ends with a line carrying a
content hash and a second-precision timestamp: the hash is what a machine compares, the time is
what a person reads, and when the statistics are unchanged the script leaves the file alone — so
running the checks cannot dirty a checkout or produce new bytes, and two copies with the same hash
hold the same statistics whatever their stamps say. (Incidental finding for anyone scripting the
client: `hf download --include` accepts repeated patterns but only honoured the last one, so pass
one pattern per invocation.)

Both scripts were then executed **inside that download**, with nothing else present:
`scripts/verify_dataset_card.py` exits 0, and `scripts/analyze.py` fails nothing — printing a skip
for the checks that compare the paper with the case report, since those narratives live in the
source repository and their absence is announced rather than passed over as a pass.

### Composition

| Path | Contents |
|---|---|
| `evidence/logs/` | 388 kilobytes: the 33-event timeout extract, 1,252 conversation-lifecycle lines from the client's task tracker, 885 per-interaction phase lines, 50 quota-error log lines with payload variants, the outcome census |
| `evidence/config/` | 108 kilobytes: the fetched error-code dictionary entries, the model-registry line and the bring-your-own-key definitions that show the 180,000-versus-1,000,000 contradiction, the selected context presets, the environment record |
| `evidence/stats/` | 44 kilobytes: 20-conversation transcript size table, the context-growth curve, the merged timeline, the round-1 request-lifecycle table |
| `evidence/incident_20260910/` | 20 kilobytes: the second collection round — 62 request episodes carrying per-request **context occupancy in tokens**, plus its own README |
| `evidence/screenshots/` | 152 kilobytes: the operator's screen showing nine consecutive timeout banners in one conversation |
| `evidence/error_messages.json` | Every string the paper quotes, verbatim, in one place |
| `analysis/summary_tables.md` | The derived statistics, regenerated and asserted by `scripts/analyze.py` |

Totals: 25 files, 724 kilobytes under `evidence/`, plus the generated analysis
table. Two collection rounds, deliberately separate: 2026-09-01 → 09-09 (frozen
bundle, conversation labels `sess-01` … `sess-20`) and 2026-09-10 (labels `S1` …,
own frozen log snapshot).

### How to load it, and how to check that this card is telling the truth

The six tabular files are declared as named configs, so a reader loads a table
directly instead of eyeballing markdown:

```python
from datasets import load_dataset

round2 = load_dataset("2makeitwork/paper_ai_Qos", name="request_lifecycle_round2")
round2["train"].num_rows          # 62 request episodes
round2["train"][0]["used_tokens_at_send"]
```

The six configs: `request_lifecycle_round1` — 308 rows, `request_lifecycle_round2` —
62 rows, `session_sizes` — 20 rows, `context_growth` — 93 rows, `timeline_events` —
51 rows, `timeout_events` — 33 rows. Everything else under `evidence/` — the log
extracts, the configuration records, the screenshot — is deliberately **not** a
config: those are line-oriented evidence files meant to be read and grepped, and
flattening them into a table would destroy the timestamps that make them
verifiable.

Two independent checks, one offline and one after upload:

```bash
python3 scripts/verify_dataset_card.py           # every declared file exists, every
                                                 # declared column matches its header,
                                                 # row counts match the card text
python3 scripts/analyze.py                       # re-derives and asserts every published figure
```

```bash
python3 -c "from datasets import load_dataset; \
  [load_dataset('2makeitwork/paper_ai_Qos', name=n)['train'] for n in \
   ['request_lifecycle_round1','request_lifecycle_round2','session_sizes', \
    'context_growth','timeline_events','timeout_events']]; print('LOADABLE')"
```

**State as published (first upload 2026-09-10, commit `16a35ca`; revised in place since).** Confirmed by the hub: the
repository is public, 36 files, and the front matter was parsed — its tags carry
`license:cc-by-4.0`, `size_categories:n<1K` and `language:en`. **Confirmed by the hub** later the same day
(2026-09-10): its conversion endpoint returned **all six** configs with their `train`
splits — `request_lifecycle_round1`, `request_lifecycle_round2`, `session_sizes`,
`context_growth`, `timeline_events`, `timeout_events` — which is what `load_dataset` and
the dataset Viewer read. Minutes after the first commit the same endpoint returned
`500 Internal Server Error`, so the conversion is asynchronous and a single early
failure means nothing. One thing this does **not** establish: the `datasets` library is
not installed on the workstation that published this, so the Python snippet above has
not been executed here — the configs are server-converted, not snippet-verified.

The non-tabular part of the bundle stays browsable and downloadable either way;
making a file loadable is not the same as making it required for reproduction.

### Collection process

A single workstation, a single subscription account, one operator, nine plus one
days. The client's runtime log tree was mirrored continuously (append-only, one
file per path and inode, each committed region re-hashed on every scan so an
in-place edit of already-written log bytes is detectable), frozen as checksummed
snapshots, then filtered to named log anchors and anonymised by script. Nothing
was typed by hand into any file under `evidence/`.

## Personal and private content

**Conversations are not included.** Full chat transcripts carry third-party
project content, so they are excluded from the bundle entirely; only statistics,
error-related log extracts and configuration records pass through. Identifiers are
replaced by a deterministic, script-built map — paths, user names, host names,
local network addresses, account and model identifiers, application programming
interface keys, and every conversation identifier (report `anonymization.md`). The
anonymizer fails with a non-zero exit code if any forbidden pattern survives its
own output, and a repository-wide gate re-checks every published file, link and
ignored directory:

```bash
python3 scripts/analyze.py                  # re-derives and asserts every published figure
python3 scripts/verify_dataset_card.py      # asserts this card against the files it declares
python3 scripts/check_release_sync.py       # compares this repository's bytes with the source
                                            # repository and the Zenodo record
```

The first two run offline and exit 0 in either repository — the source repository and this
data layer — against the files shipped here. The third reaches the hub (and Zenodo, given a
record identifier) and is the release-time check that the copy you are reading is byte-for-byte
the copy in the other places: it reports drift rather than asserting agreement, because the
three locations are updated by different commands and nothing synchronises them. Anything not
listed above is author-side tooling, or needs material deliberately not published here — the raw
client logs, which carry local paths and real conversation identifiers. The commands above are
what a reader can actually run, so they are what this card asks a reader to run.

Pseudonyms (`sess-NN` in round 1, `S1`… in round 2) are numbered by the data's own
order; the mapping to real conversation identifiers is not published and cannot be
recovered from these files.

## Uses

```bash
python3 scripts/analyze.py          # re-derives and asserts every published figure from evidence/
```

The log-side tools are source-repository material and are **not published here**:
`scripts/latency_from_logs.py` needs the raw client logs, which
carry local paths and real conversation identifiers and are never distributed. What does ship
here re-runs from these files, and `methodology.md`, "What re-runs, and from what", states the
boundary honestly rather than implying a full rebuild.

Use it to reuse the event schema, to check the paper's arithmetic, to compare your
own provider against the method, or as training data for nothing at all — see
below.

### Out-of-scope uses

Not a model-quality benchmark and not a leaderboard: it measures the service, not
the answers, and one account over ten days cannot rank providers. Not suitable as
model training data — it contains no conversational text by design. Not a
certification of the named products; the vendor's replies are collected in
`ask_vendor.md` and were not received at publication time.

## Limitations

Single workstation, single account, single model pair, ten days, no provider
cooperation. Observational except for one within-conversation pair (context
compaction). Log retention is size-based and shallow, so the earliest events of a
busy conversation are unrecoverable. The client's timeout threshold is inferred
from its own state machine, not documented by the vendor. Request **size** is
available from the client only as context occupancy; output-token and
cached-input-token counts are absent, which is why the mechanism question stays
open. State each of these whenever the data is reused.

## Citation

```
2makeitwork (independent, unaffiliated). "AI Service QoS: An Independent Outside-In
Measurement Methodology,
with Case Study 1 (Qwen3.8-Max / Qoder)." Dataset snapshot <tag or commit>, 2026.
```

**What to cite, in order.** The paper is the object; this dataset is its evidence. Cite
`paper_ai_QoS.md` at a tag for the method and the findings, this repository for the observations, and
the archived snapshot when the citation needs an identifier that cannot move: concept DOI
[10.5281/zenodo.22701430](https://doi.org/10.5281/zenodo.22701430) covers every archived version of
the released software, while each version carries its own — `v1.0.0` is
[10.5281/zenodo.22701431](https://doi.org/10.5281/zenodo.22701431) and `v1.0.1` is
[10.5281/zenodo.22701701](https://doi.org/10.5281/zenodo.22701701).

Cite the **snapshot**, name the **collection round**, and cite the **client version
plus service** rather than the model alone — a client-side watchdog misattributed to
a model is the most likely misquote. `CITATION.cff` carries the machine-readable
form; the positioning against prior measurement work is in the paper's section 1.4, with each
work's own identifier given there.

## License

Text, tables, figures and data: **Creative Commons Attribution 4.0**
(`LICENSE-content.md`). The scripts published alongside it, which re-derive and assert
every number in this card: **MIT** (`LICENSE-code.md`).