caiovicentino1/ekbasis-skopos-data

Ekbasis-Skopos Data

Model: Ekbasis-Skopos-27B · Code: github.com/OpenInterpretability/ekbasis · Site: openinterp.org/ekbasis · Earlier data: ekbasis-data

The data behind Ekbasis-Skopos-27B: every row its training lineage was trained on, from Ekbasis-27B's six stages to the two Skopos stages, and the sets it was evaluated, compared and selected on. It is self-contained: nothing here needs ekbasis-data, which stays as it was released. Every answer in the generated rows was computed, not written: by a simulator for the worlds; by running git, bash, SQLite, PostgreSQL or Python for real in a throwaway place; or, in two evaluation sets only, by a real application through its API.

What is inside

Config	Splits (rows)	What
lineage	train 339,240	Every row a training stage of the Skopos lineage held: Ekbasis-27B's six stages, v49f and R4
git3	known 1,482, held 1,623	The git test sets of the release evaluation (real git), known command types and held-out ones
guard	known 4,486, held 6,394	The larger guard set: 'Does it lose uncommitted work?' and 'Does it fail?' on fresh git scenarios (real git), known command types and held-out ones
worlds	multi_testfam 600, multi_trainfam 600, ftest_family 1,080, ftest_fresh 5,385	Simulated worlds: several questions on one state (families never trained and trained), never-trained families, and the 5x fresh confirmation set of never-trained families
confident_errors	test 15,008	The confident-errors test: 15,008 questions in 12 world families
validation	m3val 300, fval_git 1,390, fval_git2 1,514, fval_git3 1,524	The validation sets the lineage chose its checkpoints by
skopos_suites	fac_val 3,983, sess_val 730, git_long 900, git_long_val 1,800, fhorizon 1,375, latent_test 4,320	The suites R4 was compared on: factory items (shell, SQL, Python, git), shell sessions, long git sequences, long synthetic horizons and LATENT's worlds
first_skopos_selection	cal48_guard 1,994, ce49b_val_all 9,568, fxe_family 2,196, fxe_app 800, ce49b_fresh_all 6,626, g3_fresh49b 4,500, ho_rules_fresh49b 9,075, multi_fresh49b 2,371	The sets the first Skopos was selected on (cal48_guard, ce49b_val_all), FX's held-out readouts, and the fresh sets built for its V49b decision, which was never completed
calibration	fit 1,824, test 2,500	The items of the calibrated field's temperature: the fit set (fit) and its test (test)
image	test 400	The image check: 400 items from trained world families (only the image modality was never trained), each with its starting and final state drawn; the drawings were regenerated, so their pixels may differ from what the models were shown
awb_neutral	test 445	AgentWorldBench 'will the next action fail?': ids and our labels only; the sessions are rebuilt from the source with the script

Every row has: id (a hash of the row, the same as in ekbasis-data), kind (the training pool it was drawn from), stages (training rows: the stages whose training file held it), world, qtype, steps (actions in the prompt), prompt (the situation as the model reads it), question (the typed question as JSON), answer, license, source (the generator, or the upstream row), and item (the original row as JSON, with the hindsight prompt ceiling used by the training objective). answer is computed from the row's gold in item; a yes/no gold written as the string "yes" or "no" (some replay rows) is read as that word. The image config adds image_state and image_final. raw/ holds the exact JSONL files the training and evaluation code read; R4's training file is rebuilt byte for byte as cat raw/ftrain_mixG3.jsonl raw/floorPL.jsonl raw/git_plan_train.jsonl raw/fac_rx.jsonl. As read, raw/ce_items.jsonl stores yes/no golds as booleans, while confident_errors.py compares the strings "yes"/"no": normalize before scoring (the answer column already is).

from datasets import load_dataset
train = load_dataset("caiovicentino1/ekbasis-skopos-data", "lineage", split="train")
r4 = train.filter(lambda r: "R4" in r["stages"])
suites = load_dataset("caiovicentino1/ekbasis-skopos-data", "skopos_suites")

The training lineage

Qwen3.8-27B → Eikos-27B → Ekbasis-27B (½ V42 + ½ r4a) → v49f → w50, the first Skopos → R4 = Ekbasis-Skopos-27B. lineage/train holds every row any stage saw (339,240 rows, 338,530 distinct), and stages says which stages held each row. The rows of each stage's training file: 27s1 24,003, V35 117,593, V37 148,860, V41 172,850, V42 197,491, r4a 205,359, v49f 272,600, R4 255,995 distinct.

Stage	From	Training file	Mix (probability of each kind per batch item)	Steps × batch	LR	Chosen by
27s1	Eikos-27B	ftrain_m3only (24,003 rows)	floor (factory 3, labeled floor3 later) 0.85, read 0.15	1000 × 8	5e-05	m3val
V35	27s1 (step 1000)	ftrain_mixG (118,218 rows)	floor 0.15, floor3 0.15, floorG 0.3, read 0.05, replay 0.35	600 × 8	1.5e-05	fval_git
V37	V35 (step 600)	ftrain_mixG2 (149,591 rows)	floorG2 0.4, floorG 0.1, floor 0.1, floor3 0.1, read 0.05, replay 0.25	600 × 8	1.5e-05	fval_git2
V41	V37 (step 600)	ftrain_mixG2M (173,591 rows)	multi 0.4, floorG2 0.15, floorG 0.05, floor 0.1, floor3 0.08, read 0.04, replay 0.18	400 × 8	1.5e-05	fval_git2
V42	V41 (step 400)	ftrain_mixG3 (198,276 rows)	floorG3 0.35, floorG2 0.1, floorG 0.05, multi 0.15, floor 0.1, floor3 0.07, read 0.04, replay 0.14	400 × 8	1.5e-05	fval_git3
r4a	V42 (step 400)	ftrain_mixG3 + mined_wide + mined_chain (206,289 rows)	floorG3 0.245, floorG2 0.07, floorG 0.035, multi 0.105, floor 0.07, floor3 0.049, read 0.028, replay 0.098, floorM 0.2, floorC 0.1	300 × 8	1e-05	fval_git3
v49f	Ekbasis-27B (w4a5): its rank-128 adapter, continued	ftrain_mixG3 + 8 files (273,529 rows)	multi 0.0735, floor 0.049, floor3 0.0343, read 0.0196, replay 0.0686, floorG3 0.1715, floorG2 0.049, floorG 0.0245, floorGV 0.0227, floorRXsh 0.0444, floorRXgit 0.0394, floorRXsql 0.0296, floorC 0.0189, floorGA 0.2, floorFX 0.155	900 × 8 (micro-batch 4)	1.5e-05	fval_git3; λ on cal48_guard, m3val
w50	w4a5 and v49f	none: WiSE-FT at λ = 0.5, merged				cal48_guard, m3val, ce49b_val_all
R4	w50 (merged), a new rank-64 LoRA	ftrain_r2 (256,705 rows)	floorG3 0.1925, floorG2 0.055, floorG 0.0275, multi 0.0825, floor 0.055, floor3 0.0385, read 0.022, replay 0.077, floorPL 0.15, floorPLG 0.15, floorRX 0.15	1200 × 8 (micro-batch 4)	1.5e-05	fval_git3 (final step)

The first six stages are Ekbasis-27B's, as in ekbasis-data: LoRA rank 64 (alpha 128) on every linear layer; cross-entropy on the letter readout plus a JEPA-style term (weight 3, layers 16, 32, 48, 64, at the end of the evidence); each batch item drawn from a kind with the mix's probability.

• v49f continued Ekbasis-27B's own adapter (rank 128) for 900 steps on V42's training file plus F's executed factory data, the guard-style git anchors and FX's breadth sample (v49_fx: 41 families, among them 2,000 rows converted from CWM traces and 600 from ShIO command lines). Its first attempt ran out of GPU memory at step ~500 and was discarded; the stage is the rerun from step 0 with micro-batches of 4 (the same 8 items per step).
• w50, the first Skopos, is not a training stage: the exact halfway interpolation between the w4a5 and v49f adapters (one adapter of rank 256, W0 + ½ ΔW(w4a5) + ½ ΔW(v49f)), merged. It was chosen on validation only (first_skopos_selection: cal48_guard, ce49b_val_all, with m3val) and was never released.
• R4 trained a new rank-64 LoRA on the merged first Skopos for 1,200 steps, on the public ftrain_mixG3 plus long synthetic sequences (floorPL), long real git sequences (floorPLG) and regenerated factory data (floorRX); the final step was merged and is Ekbasis-Skopos-27B. Full recipes: recipes.json.

Kinds added after Ekbasis-27B: floorGV (V44's git family), floorRXsh, floorRXgit, floorRXsql (F's factory: bash, git and SQLite run for real), floorGA (fresh guard-style git items with their right labels), floorFX (FX's families: shell, git, SQLite, PostgreSQL, Python, side effects, and the CWM and ShIO conversions), floorPL (4–16 actions in the trained world families), floorPLG (4–16 real git commands) and floorRX (F's factory regenerated with fresh seeds: shell, SQL, Python, git).

Evaluation sets and their relation to the training data

The labels are the overlap audit's, for every set it covered ("Audited": yes); the others carry this build's label and say "no". in-distribution: the same generator, families and question types as some training rows, with seeds no training row used; scores on these sets measure the trained distribution, not transfer. mixed: some groups of the set are in-distribution and others are not (see the note). held-out: no training generator makes the set's items. held out of the generator, not of training: the git sets' held-out command types are held out of their generator, but Skopos' later stages trained the same command types through the shell and git factories.

Split	Rows	Distribution	Audited	Note
git3/known	1,482	in-distribution	yes	gitbox3 (conseq/gen_git3.py, seeds 1910000+), the generator of floorG3 (Ekbasis-27B) and floorPLG (R4); known command types
git3/held	1,623	held out of the generator, not of training	yes	gitbox3 with the held command types (git rebase , git restore --source=HEAD~1 ), never in gitbox3 training rows; BUT Skopos' later stages trained the same command types through the shell/git factory (v45rx_git, v49_fx, fac_rx: 'git rebase ' in 945 rows, 'git restore --source= ' in 815 rows)
guard/known	4,486	in-distribution	yes	gitbox3 (conseq/gen_guard_big.py, seeds 2910000+), known command types: the generator of floorG3/floorGA/floorPLG
guard/held	6,394	held out of the generator, not of training	yes	gitbox3 held command types (as git3_test_held, same caveat: the command types are in the factory rows of v49f and R4)
worlds/multi_testfam	600	held-out	yes	conseq/gen_multi.py, never-trained families (cards, timers, machines appear in no training file)
worlds/multi_trainfam	600	in-distribution	yes	conseq/gen_multi.py, trained families (seed 2; training multi rows seed 1)
worlds/ftest_family	1,080	held-out	yes	conseq/gen_factory.py TEST families (cards, timers, machines), never trained
worlds/ftest_fresh	5,385	held-out	yes	V50R/scripts/gen_ftest_fresh.py, the same never-trained families, fresh seed, firewalled against every v50p file
confident_errors/test	15,008	mixed	yes	MIXED: group T trained families (in-distribution), H trained families with the held question type, U never-trained families (conseq/confident_errors.py)
validation/m3val	300	in-distribution	yes	conseq/gen_m3only.py, factory-3 items like floor3 (seed 71 vs 65)
validation/fval_git	1,390	mixed	no	git v1 (floorG) 640, factory 3 300 and the never-trained families Track and Tally 450, as fval_git3; chose V35's checkpoint
validation/fval_git2	1,514	mixed	no	git v2 (floorG2) 764, factory 3 300 and the never-trained families Track and Tally 450, as fval_git3; chose V37's and V41's checkpoints
validation/fval_git3	1,524	mixed	yes	MIXED validation set (checkpoint selection and calibration fit): gitbox3 known types 774 + factory-3 m3val 300 (in-distribution) + Track/Tally 450 (never-trained families)
skopos_suites/fac_val	3,983	in-distribution	yes	the factory of fac_rx (run_family.py, seeds 200000+ vs 100000+), byte-identical to the F factory of v45rx_*; rows whose floor is in fac_rx dropped, NOT checked against v45rx_*/v49_fx
skopos_suites/sess_val	730	in-distribution	yes	fac_val's 1-command shell rows rendered as agent sessions (gen_session.py); content from the factory generator, session layout trained only by the R3 sibling, not by R4
skopos_suites/git_long	900	in-distribution	yes	V50P gen_git_long.py, gitbox3 sequences of 5/8/12 commands; floorPLG (R4) is gitbox3 sequences of 4-16 commands
skopos_suites/git_long_val	1,800	in-distribution	yes	V50R gen_git_val.py, gitbox3 5/8/12 commands, the validation twin of git_long (floorPLG's generator)
skopos_suites/fhorizon	1,375	in-distribution	yes	V50P build_data.py = conseq/gen_horizon.py: the training families of worldgen (kind floor, 1-3 actions) and floorPL (5/8/12 actions); 20 actions never trained
skopos_suites/latent_test	4,320	held-out	yes	DM/mission/LATENT worlds (Tetris, Robot, Stock, Switches, Files; held-out Columns, Boxes, Stack, Bank): no Ekbasis training kind uses them ('trainworld' refers to the LATENT predictor's split)
first_skopos_selection/cal48_guard	1,994	in-distribution	no	the generator of the floorGA anchors (gitbox3 guard-style scenarios), unseen seeds; the first Skopos' lambda selection
first_skopos_selection/ce49b_val_all	9,568	mixed	no	groups T, H and U, as confident_errors; the first Skopos' lambda selection
first_skopos_selection/fxe_family	2,196	held-out	no	FX's held-out families (reported, not a gate)
first_skopos_selection/fxe_app	800	held-out	no	an app in no training file (reported, not a gate)
first_skopos_selection/ce49b_fresh_all	6,626	mixed	no	groups T, H and U, as confident_errors; built for the first Skopos' V49b decision, which was never completed: no verdict was recorded
first_skopos_selection/g3_fresh49b	4,500	held-out	no	the rules_stress capability battery, which no training generator makes; built for the first Skopos' V49b decision, which was never completed: no verdict was recorded
first_skopos_selection/ho_rules_fresh49b	9,075	held-out	no	the rules_stress capability battery, which no training generator makes; built for the first Skopos' V49b decision, which was never completed: no verdict was recorded
first_skopos_selection/multi_fresh49b	2,371	held-out	no	families never trained; built for the first Skopos' V49b decision, which was never completed: no verdict was recorded
calibration/fit	1,824	mixed	its rows are	fval_git3 (mixed in the overlap audit) and m3val (in-distribution in the audit); R4's calibration fit
calibration/test	2,500	in-distribution	its rows are	git_long, guard_known and fac_val, each in-distribution in the overlap audit, whose report labels the calibration test so
image/test	400	mixed	yes	worldgen Toggles/Jugs = trained families (kind floor), 1-3 actions; the image modality was not in V45-R4 training
awb_neutral/test	445	held-out	yes	Qwen/AgentWorldBench trajectories (external), labels from the real observation

fac_val's Python slice is small: 140 of the generator's 576 validation rows are left after dropping the 436 whose prompt equals a training prompt; the Python generator repeats its prompts across seeds.

Never in training rows, but used in validation-based selection. These sets chose things, so scores on them are not untouched tests:

• validation/fval_git3, with its 450 items of the never-trained families Track and Tally, is the validation set the recipes of V42, r4a, v49f and R4 name for their checkpoint (in every stage the checkpoint kept is the last step) and part of the temperature fit of the calibrated field (calibration/fit). fval_git (V35) and fval_git2 (V37, V41) hold the same 450 Track/Tally items; m3val served 27s1 and the temperature fit.
• first_skopos_selection/ce49b_val_all, whose group U includes the never-trained families Cards, Timers and Machines (those of worlds/ftest_family and worlds/ftest_fresh), chose the first Skopos' λ, together with cal48_guard and m3val.

What is not here, and why

• Replay rows not redistributed: 7,423 (7,348 distinct), the same as in ekbasis-data. Only v49f's training file held them (R4 read the public ftrain_mixG3). Only replay rows that are rows of the published eikos-decisions are redistributed, each with its eikos-decisions id and upstream license in source and license; the others are listed by id in checks.json.
• Rows flagged by the privacy scan: 60. Every row of every file was scanned with the Eikos release's scanner (credentials, e-mail addresses at consumer domains, checksum-valid payment cards, SSNs, IBANs, CPFs); a flagged row is withheld, never edited, and listed by id in checks.json. 41 of them were rows that would otherwise be here. By source: replay rows of ftrain_mixG3 19; ext_cwm_python rows of v49_fx 26; sql_collation_affinity rows of v49_fx 5; awb_neutral/test 10.
• AgentWorldBench sessions. awb_neutral holds our ids, questions and labels only. The sessions are agents' real trajectories from Qwen/AgentWorldBench (Apache-2.0); build_awb_neutral.py (code repository) rebuilds the 455 items from its files at revision 6b8d284 (drop the script's awb_term_lists rows, a question type dropped at design time): 455 of 455 rebuilt rows are identical to the evaluated ones, so the script rebuilds the full 455-turn set. Each row's id is the hash of the full rebuilt row (as in every config), so a rebuilt row can be matched to its label. 10 of them are withheld here: the privacy scan matched a payment-card pattern in their upstream trajectory id (reviewed as a false positive; the rule is applied without exceptions); checks.json lists them by this dataset's row hash.
• The image drawings were redrawn. The image items come from trained world families (Toggles and Jugs, 1–3 actions); only the image modality was never trained in the last stages. The items were not saved when the check ran; they were regenerated from its seed with its own code, without any model. 400 of 400 items match the check's per-item record (world, whether the actions change the answer, answer). The drawings were made with Pillow 10.4.0, so their pixels may differ from what the models were shown when the check ran (the text labels' fonts in particular).
• Sets used only for Ekbasis-27B (the git v2 test sets of its 240-question comparison) stay in ekbasis-data.
• The first Skopos' fresh image sets. Its V49b plan also had fresh image sets; their items were generated at read time and never saved, so they are not here. Its text fresh sets are in first_skopos_selection.

Checks

• Training rows are what was trained on. 7 of the training files carry a SHA-256 recorded by the training orchestrator when a run read them; all match. The two files made for v49f (v49_fx, v49_anchor2) have no recorded hash; their row counts match its plan. R4's training file is, byte for byte, the public ftrain_mixG3 followed by floorPL, git_plan_train and fac_rx (rebuilt from raw/ and checked). For the 198,721 rows of ekbasis-data's lineage/train, the six Ekbasis-27B stages computed here are those of ekbasis-data (0 differ).
• raw/ is what the code read. 29 of 29 evaluation files in raw/ are byte for byte the files read (7 of 7 taken from ekbasis-data are also identical to the copies R4's evaluations read on the RTX); 11 of 13 training files are, and the other two had rows withheld (ftrain_mixG3, v49_fx). Any re-encoding (yes/no answers, JSON as text) is in the parquet configs only; hashes in checks.json and MANIFEST.sha256.
• No evaluation or validation row is also a training row as a whole: 0 rows across all evaluation splits (checks.json, identity_overlap).
• Overlap of prompts (identical and near-duplicate).

Checked against every training row of the lineage, the Ekbasis-27B stages, v49f's and R4's files included: an identical prompt (also against a training row's hindsight prompt), or a near duplicate (word 8-gram Jaccard >= 0.5 against one training text after removing each set's own layout (Ekbasis-27B's audit rule, exact best match)).

Split	Items	Identical prompt	Near duplicate	Flagged	Same prompt, question and answer
git3/known	1,482	0	0	0	0
git3/held	1,623	0	0	0	0
guard/known	4,486	0	0	0	0
guard/held	6,394	0	0	0	0
worlds/multi_trainfam	600	5	286	291	5
worlds/multi_testfam	600	0	0	0	0
worlds/ftest_family	1,080	0	0	0	0
worlds/ftest_fresh	5,385	0	0	0	0
skopos_suites/fac_val	3,983	6	99	105	3
skopos_suites/git_long	900	0	0	0	0
skopos_suites/git_long_val	1,800	0	0	0	0
skopos_suites/sess_val	730	0	0	0	0
skopos_suites/fhorizon	1,375	0	547	547	0
skopos_suites/latent_test	4,320	0	0	0	0
awb_neutral/test	455	0	0	0	0
validation/fval_git3	1,524	0	0	0	0
validation/m3val	300	0	0	0	0
confident_errors/test	15,008	174	5,207	5,381	104
image/test	400	0	5	5	0

Not covered by the audit: validation/fval_git, validation/fval_git2, first_skopos_selection/cal48_guard, first_skopos_selection/ce49b_val_all, first_skopos_selection/fxe_family, first_skopos_selection/fxe_app, first_skopos_selection/ce49b_fresh_all, first_skopos_selection/g3_fresh49b, first_skopos_selection/ho_rules_fresh49b, first_skopos_selection/multi_fresh49b (the calibration items are rows of audited sets).

• Rebuilt from their sources: latent_test (4,320 of 4,320 rows from LATENT's test trajectories), fac_val (3,983 of 3,983 rows from the factory's validation files) and awb_neutral (above).
• No outputs of Claude, Jev or any other closed model are in the training rows. The rows added by v49f and R4 were generated by programs and real executions, or converted from CWM's execution traces and ShIO's command lines. The replay rows are as described in ekbasis-data and the eikos-decisions card.

Licenses and attribution

The generated rows (worlds, git, shell, SQL, Python and, in evaluation sets only, application scenarios) are released under Apache-2.0. Rows derived from external datasets keep their licenses, given in the license column of each row:

• CWM rows (1,974, kind floorFX, family ext_cwm_python): CC BY 4.0 and the license of the source repository (cc-by-4.0 AND <license>): mit 723, apache-2.0 692, bsd-3-clause 437, mit-0 56, bsd-2-clause 50, unlicense 11, isc 5. MIT-0 is not among the Hub's license identifiers, so it is named here and in each row's license, not in the card's metadata. Converted from marin-community/swe-rebench-v2-CodeWorldModeling, itself derived from nebius/SWE-rebench-V2; only permissively licensed repositories. Each row's source names its instance, test and repository; the values are those recorded by that dataset's tracer (not re-executed by us). Every row's repository license was checked against the dataset's license file: 1,974 of 1,974 match. THIRD_PARTY_LICENSES/ holds the license files of all 311 repositories (421 files), fetched at the commit each instance's rows came from (the instance's base_commit in SWE-rebench-V2), with an index; pypa/setuptools has no license file at af8b32284875 (pypa__setuptools-4980; its other commits' files are included).
• ShIO rows (600 training rows, 200 in fxe_family): CC BY 4.0. From jragsdale1/ShIO-bash-26.1: only the command lines, rewritten to relative paths and re-executed in our sandbox; the questions and answers are ours and ShIO's labels are not used.
• Replay rows: as in ekbasis-data: eikos-decisions (CC BY 4.0) with its upstreams' licenses.
• awb_neutral: our ids, questions and labels (Apache-2.0); the sessions stay at their source (Apache-2.0).

Credits:

Source	License	Credit
FinEntity	ODC-BY 1.0	Tang et al. (2023), FinEntity: Entity-level Sentiment Classification for Financial Texts, EMNLP 2023
TAT-QA	CC BY 4.0	Zhu et al. (2021), TAT-QA: A Question Answering Benchmark on a Hybrid of Tabular and Textual Content in Finance, ACL 2021
GSM8K (train)	MIT	Cobbe et al. (2021), Training Verifiers to Solve Math Word Problems
eikos-decisions	CC BY 4.0	Vicentino (2026), Eikos Decisions
ShIO-bash-26.1	CC BY 4.0	Ragsdale and Boppana (2026), ShIOEnv: A Command Evaluation Environment for Grammar-Constrained Synthesis and Execution Behavior Modeling, arXiv:2505.18374
swe-rebench-v2-CodeWorldModeling	CC BY 4.0 + each repository's license	Marin Community (2026); Badertdinov et al. (2026), SWE-rebench V2, arXiv:2602.23866
AgentWorldBench (evaluation pointers only)	Apache-2.0	Qwen team, Qwen/AgentWorldBench

Attribution: Contains data derived from ShIO-bash-26.1 (jragsdale1, CC BY 4.0) and from swe-rebench-v2-CodeWorldModeling (marin-community, CC BY 4.0; only repositories with a permissive license), converted; ShIO's command lines were re-executed in our sandbox, and the CWM values are those recorded by its tracer.

Contact

Questions about the data, or a row that should not be here: caio@openinterp.org.

Citation

@misc{ekbasis2026skoposdata,
  title  = {Ekbasis-Skopos Data: the training lineage and evaluation sets of Ekbasis-Skopos-27B},
  author = {Caio Vicentino},
  year   = {2026},
  url    = {https://huggingface.co/datasets/caiovicentino1/ekbasis-skopos-data}
}