Break the Agent
Junction 2026 · AfterQuery challenge · an RL environment where frontier agents fall short for real reasons2026-11-15T10:00+02:00Project coord/project.md
Concept
Not chosen yet. Deciding the setting is task choose-setting; the outcome goes into coord/decisions/ and replaces this section.
What the concept has to deliver, in order of points:
- A gap between the frontier agent (OpenCode via Harbor, over MCP) and a reference run we can demonstrate and reproduce.
- Meaningful difficulty: failures we can trace to decisions the agent made, with the needed information and tools available to it.
- Reward integrity: do-nothing and stop-early score near zero, and no shortcut beats honest play.
- Craft: one command in the README reruns everything.
State
Repo and coordination structure are set up. No environment code yet. Next: get Harbor and OpenCode running (starter-kit-harness) and pick the setting (choose-setting); they can run in parallel.
Links
- Live board (public, updates about a minute after each push to
coord/): https://junction-board.pages.dev - Repo: https://github.com/VrabelPeter/hack_junction26
Required stack and submission (AfterQuery, 14 Nov)
- Environment = a Harbor task; played with
harbor run -p <task> -a opencode -m <provider/model>; verifier writes one score 0..1 to/logs/verifier/reward.txt. - Submit: at least one Harbor run log with its score, a short README (what the agent does, why it is hard, how it is scored), a demo video with a playthrough.
- AfterQuery gives no model credits. We use the Google, OpenAI and Modal credits from the other sponsors.
- Details: end of
docs/challenge.md, anddocs/harness-notes.md.
Open facts to fill in
- Sponsor resources and how we use them:
docs/resources.md. Proposed headline model:google/gemini-4-carbon(Gemini credits). Still open: the size of the Gemini grant, which caps how many runs we can afford. - Whether a second container (docker-compose) is allowed, and which model the judges rerun with. Full question list: end of
docs/harness-notes.md. - How the standard harness runs the stop-early baseline.
Schedule
Submissions open Sat 14 Nov 12:00. Final submission Sun 15 Nov 10:00, review from 10:30.
The gap latest finished eval: reference vs frontier agent vs baselines
python3 tools/coord.py new exp "..." --kind eval, then fill in reference, agent (one score per run), noop and stop_early and set status=done. This panel then shows the gap the judges will re-measure: reference run, three agent runs, do-nothing, stop-early.Rubric coverage tasks done per judging criterion
Tasks click a card for details
○To do11
Add do-nothing and stop-early baselinesP1integritywaits on env-implementation, reward-function
Goal
The two baselines the judges will run: an agent that takes no action, and one that stops after the first few steps. Both must score little or nothing.
Done when
- ☐ Both baselines runnable through the same entry point as the real evaluation
- ☐ Scores recorded in an eval experiment
- ☐ If either scores meaningfully above zero, a task is opened to fix the reward
Notes
Update 2026-11-14 (peter): organisers' required-stack post
Do-nothing is Harbor's built-in -a nop. Stop-early has no built-in: until the mentors say how they run it, implement it as a variant of the reference script that quits after the first few periods.
Prepare the 10-minute demoP1craftwaits on failure-analysis, one-command-eval-readme
Goal
A rehearsed 10-minute walkthrough: why this setting, the environment live, the gap, the agent's mistakes with evidence, and why the reward holds up.
Done when
- ☐ Outline with time per part
- ☐ One recorded agent failure ready to show, plus the reference run succeeding
- ☐ Rehearsed once end to end
- ☐ Fallback if live runs are slow: pre-recorded outputs
Notes
Update 2026-11-14 (peter): organisers' required-stack post
A demo video is part of the submission, and the organisers encourage showing a playthrough in it. Plan the recording, not only the live walkthrough: one agent run failing and the reference run succeeding, from real Harbor run logs.
Implement the environment as an MCP serverP1craftwaits on env-spec, starter-kit-harness
Goal
The environment itself: world or simulator logic, the MCP tools the agent calls, deterministic seeding, and a trajectory log of every observation, action and reward.
Done when
- ☐ Runs under the Harbor + OpenCode harness
- ☐ Deterministic for a fixed seed
- ☐ Invalid, out-of-range and out-of-order tool calls are handled with clear errors, never crashes or free reward
- ☐ Every episode writes a trajectory log to
runs/ - ☐ Unit tests for the world rules
Notes
Update 2026-11-14 (peter): organisers' required-stack post
The deliverable is a Harbor task directory (instruction.md, task.toml, environment/, tests/, solution/). Keep the simulator a plain Python module that also runs in-process, so the reference run, the unit tests and the post-training experiment can step it without Harbor.
MCP tool schemas: every argument exactly one explicit type, no optional/nullable/union types, or Gemini rejects every request (docs/resources.md).
Specify goal, actions, observations, reward and episode endP1difficultywaits on choose-setting
Goal
A short written spec of the environment that the implementation, the reference run and the evaluation all build against, so they can proceed in parallel.
Done when
- ☐ Goal stated in one or two sentences
- ☐ Action space: the MCP tools, arguments, and what each does
- ☐ Observation space: what the agent sees at the start and after each action
- ☐ Reward: formula, range, when it is given, and why do-nothing and stop-early score near zero
- ☐ Episode start, termination, step or resource limits, seeding
- ☐ What the agent is told up front (the task prompt) - checked for fairness: nothing needed to succeed is hidden
Notes
Put the spec in docs/env-spec.md and record contested choices as decisions. Interface changes after this point must be announced with a message to all.
Explain the agent's main mistakesP1difficultywaits on frontier-agent-runs
Goal
A written analysis of where and why the frontier agent falls short: each main mistake tied to a decision in the task, with evidence that the information and tools to do better were available.
Done when
- ☐ 2 to 3 main failure modes, each with quoted evidence from trajectories
- ☐ Each traced to a decision point and its cost in score
- ☐ Fairness check passed: no failure caused by hidden information, wording, timing or broken tools
- ☐ Written up in
docs/failure-analysis.mdand summarised in the README
Notes
Use the trajectory-analyst subagent on the run logs.
Run the frontier agent at least three times and record scoresP1gapwaits on env-implementation, reward-function
Goal
Run OpenCode with the frontier model through the harness on the real environment, repeatedly, and record every score next to the reference run.
Done when
- ☐ At least 3 runs with the judging configuration, trajectories kept
- ☐ Registered as a
--kind evalexperiment withreference,agent,noop,stop_earlyfilled in - ☐ The gap is consistent across runs (if not, say so and open a task)
Notes
Watch the credit budget; note cost per run in the experiment file.
Update 2026-11-14 (peter): organisers' required-stack post
AfterQuery gives no credits; the model comes from the Google or OpenAI sponsor credits and is our choice. Record provider, model and cost per run in the experiment. If budget allows, repeat on the other provider. Ask the mentors which model the judges rerun with.
Update 2026-11-14 (peter): models
Headline: google/gemini-4-carbon. Smoke runs: google/gemini-3.8-flash or DeepSeek on Verda. Second family if budget allows: Kimi K3.1 Pro on Verda. The OpenAI sponsor credits cannot pay for OpenCode runs. See docs/resources.md.
One-command evaluation and README for judgesP1craftwaits on reference-run, baselines-noop-stop-early, frontier-agent-runs
Goal
A single command in the README that runs the reference run, three agent runs, do-nothing and stop-early with the standard harness and prints the scores we report.
Done when
- ☐ Works from a fresh clone on a machine that has never run it
- ☐ README: why this setting, what an agent can learn, rules, how to run, reported results
- ☐ The reported numbers match what the command prints
Notes
Start a skeleton of this command as soon as the environment runs, and keep it green on main.
Update 2026-11-14 (peter): organisers' required-stack post
- The README must say, briefly: what the agent has to do, why it is hard, how it is scored. The organisers warn that AI-generated READMEs "may communicate your environment's value poorly", so a human on the team should write or rewrite the final text.
- The submission must include at least one full Harbor run log with its score.
runs/is ignored by git, so copy one intoresults/. - The command wraps
harbor run -p <task> -a oracle,-a opencode -m <model> -k 3,-a nop, and the stop-early baseline; it needs the model key from.env.
Build the stronger reference runP1gapwaits on env-implementation
Goal
A run that clearly outscores the frontier agent and that we can demonstrate live and reproduce: for example a solver, search, or scripted expert policy using only the same tools and information the agent has.
Done when
- ☐ Reproduces the same score across repeated runs and on a second teammate's machine
- ☐ Uses only actions and information available to the agent (otherwise the gap is not fair)
- ☐ We can explain in one minute why it does better
Notes
Implement the reward and scoringP1integritywaits on env-spec
Goal
Scoring that measures success at the task and nothing else, computed from real environment state rather than anything the agent claims.
Done when
- ☐ Implemented against the spec, with tests for edge cases
- ☐ Do-nothing scores about zero; stop-early scores little
- ☐ Bounded: no term can accumulate without limit or be farmed
- ☐ Completing the task well is the highest-scoring strategy we know of
Notes
Any later change here means rerunning the baselines and the reward-redteam subagent.
Update 2026-11-14 (peter): organisers' required-stack post
The final reward is a single number from 0 to 1 in /logs/verifier/reward.txt; partial credit is allowed. Normalise so the do-nothing policy maps to 0 and the reference to a high score, and clip. Keep sub-scores in our own log, not in the reward file. Compute it from simulator state the agent cannot write (docs/harness-notes.md, "What this means for our design").
Red-team the reward for exploitsP1integritywaits on reward-function, env-implementation
Goal
Do the judges' 15-minute exploit hunt ourselves, repeatedly, until nothing that avoids the task beats honest play.
Done when
- ☐
reward-redteamsubagent run against the current environment - ☐ Findings recorded as a
--kind redteamexperiment - ☐ Every confirmed exploit fixed and re-tested
- ☐ A second teammate (or their agent) who did not write the reward has tried to break it
Notes
Rerun after every reward or tool-surface change.
Stretch: train a smaller model on environment experienceP2stretchwaits on env-implementation, reference-run
Goal
Show a smaller model improving after training on experience from the environment (for example imitation of reference trajectories or a simple RL loop). Only a tiebreaker: start it once the four main criteria are covered.
Done when
- ☐ Before and after scores on held-out seeds
- ☐ Training command and data generation are reproducible
Notes
Update 2026-11-14 (peter): organisers' required-stack post
The organisers now list "some post-training experiments" among what they are looking for, and Modal credits are available for the GPU. Priority raised from 3 to 2. Cheapest credible version: log reference-policy trajectories from the simulator, fine-tune a small open model on them on Modal, and report before and after scores on held-out seeds. Design the environment so it can be stepped in-process without Harbor, or collecting experience will be too slow.
Update 2026-11-14 (peter): which model, where
Proposal: Gemma 4 E4B (or E2B), LoRA with the Unsloth recipe on a Modal L40S, trained on reference-policy trajectories; evaluated in-process on held-out seeds, before and after. Also eligible for the "Best Use of Gemma" and "Best use of Modal" side challenges. Details and cost traps: docs/resources.md.
●In progress2
Choose the environment setting and write the decisionP1difficulty@peter
Goal
Pick the world we build. This is the highest-leverage choice of the weekend: 60 of 100 points (gap + meaningful difficulty) are decided by whether the setting produces a real, explainable gap.
Done when
- ☐ 3 to 5 candidate settings compared against the criteria below
- ☐ Cheap evidence for the favourite: a quick manual or scripted probe showing a frontier model actually struggles
- ☐ Decision recorded with
new decision, andcoord/project.mdConcept section rewritten
Notes
Criteria for a good setting:
- A frontier agent plausibly fails for a reason we can name (planning depth, exploration, resource limits, adapting to new information), not because of missing information or awkward tooling.
- A reference run that is clearly stronger is feasible for us to build and reproduces exactly (a solver, a search, a scripted expert policy).
- The reward can be computed from real environment state, so it is hard to fake; doing nothing and stopping early naturally score about zero.
- Episodes are short and cheap enough to run many times in 48 hours.
- Rules make sense for the setting and fit in a short description.
- Bonus: produces experience a small model could learn from (stretch goal).
Ask the on-site mentors for a design review before committing.
Research, 2026-11-14 (peter)
Harness facts this builds on are in docs/harness-notes.md. Two of them drive the choice:
- The agent under test has a shell and can script calls to our MCP server, so
a setting that a solver cracks is not safe: the agent can write the solver.
- The judges' own paper (StoreBench) got its gap from scarce operations plus
hidden events, not from horizon length. Without shocks, frontier models with a coding harness beat their scripted operator.
Candidates
| # | Setting | Why a frontier agent should fall short | Reference run | Reward and baselines | Build cost | Main risk | |---|---|---|---|---|---|---| | A | Metered operations with delayed consequences: run a small operation for N periods; every tool call, reads included, costs one of K operations per period; orders and repairs take effect after a delay; conditions change on announced, rumoured and silent channels | The failure modes the judges measured themselves: under-investing, missing silent changes, spending the budget on reading, declaring done early | Scripted triage heuristic using only the agent's tools | Terminal books after settlement, normalised between the absentee policy and the reference; do-nothing and stop-early land at about 0 by construction | Medium: one simulator, about 8 to 12 tools | Reads as a small StoreBench unless the setting is clearly ours; balancing takes iterations | | B | Unknown machine: a black-box process with hidden response curves; limited noisy experiments, then a production phase | Poor experimental design, anchoring on the first hypothesis | Scripted design-of-experiments plus model fit | Production output from simulator state | Low | The agent can fit models in Python too; weakest evidence for a gap | | C | Online dispatch: jobs arrive over time, limited vehicles or crews, disruptions | Greedy, reactive play instead of holding capacity for what is forecast | Rolling-horizon heuristic | Value served by the end | Medium | Fully visible state invites the agent to script the same heuristic | | D | Hidden-rule puzzle worlds (in the style of ARC-AGI-3): mechanics must be discovered by acting | Large documented gap between frontier agents and people on novel interactive games | State-graph explorer with no knowledge of the rules | Levels completed, weighted by action efficiency | Low to medium | "Hidden rules" can be judged as withheld information; text grids make perception, not decisions, the bottleneck | | E | Incident response in a simulated service: diagnose and repair with side effects | Acting before diagnosing | Scripted runbook | Uptime over the episode | High | A runbook that knows the fault classes is a privileged reference; the simulator is the largest of the five |
Recommendation (not yet a decision)
A, in a setting that is not a shop. It is the only candidate whose failure modes are already measured on frontier models, by the people judging us, and its structure answers three rubric rows at once: metering defeats brute-force scripting (gap), every lost point traces to a logged allocation decision (difficulty), and terminal settlement makes quitting worthless (integrity).
Setting proposal: spacecraft operations. Contact windows make a per-period command budget physically natural, telemetry is the read cost, consumables (power, storage, propellant) are the scarce resources, slews and uploads are the delays, and faults develop silently in channels the operator has to choose to look at. Score is the science value downlinked by end of mission, which is zero if you do nothing. Alternatives with the same skeleton: a hospital blood bank (perishables, lead times, strong textbook heuristics for the reference) or a winter road-maintenance depot. The simulator core is the same, so the flavour can still change after the probe.
What makes it fail: the gap is a hypothesis until a frontier model has played it. If the first probe shows the agent matching the scripted reference, tighten the operation budget and add silent events before adding anything else; if it still matches, fall back to D.
Before this can be decided
- ☐ Mentor design review of A (questions in
docs/harness-notes.md) - ☐ Probe: needs the harness running and model credits, neither of which exists on any machine yet. A 2 to 3 hour throwaway version of A (3 tools, 20 periods) is enough to see whether the agent under-invests and stops early
- ☐ Team agrees, then
new decisionand rewrite the Concept section ofcoord/project.md
Update 2026-11-14: organisers' required-stack post
Does not change the recommendation; it changes three inputs:
- The model is ours to pick (Google or OpenAI sponsor credits). On StoreBench's short tasks the GPT and Gemini models tested scored 0.54 and 0.55 against 0.76 for the scripted operator, a wider gap than the best model overall (0.70). That was under a different harness, so it is encouragement for candidate A, not proof.
- Cost now matters. Episode length has to fit our own credits; fix the horizon after measuring one toy run.
- Post-training is wanted, not just a tiebreak. Candidate A suits it: the reference policy generates unlimited labelled experience from the simulator.
Still open before deciding: whether a second container is allowed (question 1 in docs/harness-notes.md), and a probe run.
Get the AfterQuery starter kit running end to endP1craft@peter
Goal
Have Harbor + the OpenCode agent talk over MCP to a trivial placeholder environment on our machines, using the provided scoring skeleton. Everything else builds on this loop, so it comes first.
Done when
- ☐ Starter kit / harness docs are in the repo or linked from
coord/project.md - ☐ A toy MCP environment (one tool, trivial reward) runs under the harness and produces a score
- ☐ Exact setup steps and commands are written down so every teammate can repeat them
- ☐ Model, credits budget and rate limits are noted in
coord/project.md
Notes
Write down early what the harness expects from an environment (MCP tool schema, how reward is reported, how an episode ends, how do-nothing and stop-early baselines are run). env-spec depends on those answers.
Update 2026-11-14 (peter): organisers' required-stack post
There is no separate starter kit: it is public Harbor (uv tool install harbor, needs Docker) with OpenCode, run as harbor run -p ./my-task -a opencode -m [provider/model]. Background and the upstream MCP example to copy: docs/harness-notes.md.
Changes to "done when":
- The toy task writes one number 0..1 to
/logs/verifier/reward.txt. - No AfterQuery credits. Get a Google or OpenAI key from the sponsor credits into
.env, and record model, cost per run and rate limits incoord/project.md. - Test both layouts and report which works: a second container via
environment/docker-compose.yaml, and a single Dockerfile with the simulator under a different OS user from the agent. - Run
-a oracleand-a nopon the toy task and record what each does, and what reward an agent timeout produces.
2026-11-14 (peter, claimed)
Done so far: Harbor 0.26.0 installed in .venv with Modal support; facts confirmed from source are in docs/harness-notes.md; .env.example added. Not done: no trial has run yet. Blocked on a model key in .env and either local Docker (needs sudo) or a Modal token.
⚠Blocked0
✓Done1
Set up the repo and agent coordination structureP1infra@peter
Goal
A git repo that several Claude Code agents can collaborate through: shared instructions, file-based tasks / experiments / messages, and an HTML board.
Done when
- ☑
CLAUDE.mdwith the protocol - ☑
coord/structure andtools/coord.py - ☑ HTML board builds from
coord/
Notes
Done in the initial commit. Still to do by a human: create the remote, push, and invite teammates (see README).
Experiments
| Status | Experiment / result | Kind | Owner | Host | When |
|---|---|---|---|---|---|
| ✓Done | Toy MCP task on Modal: oracle and nopHypothesisDoes Harbor run a two-container task on Modal without local Docker, does the oracle reach the MCP sidecar, and does the verifier read the score from the sidecar? Expect oracle 1.0, nop 0.0. SetupExact command, seeds, model, env commit - enough for a teammate to rerun it. ResultsTakeawaysResults
Exact commands, from the repo root with No seeds: the toy is deterministic. Takeaways
coord/experiments/1114-0332-toy-mcp-task-on-modal-oracle-and-nop.md · .venv/bin/harbor run -p probes/toy-mcp -a oracle -e modal -o runs/toy (then -a nop)oracle 1.0, nop 0.0 on Modal, about 1 min per trial, no local Docker | probe | @peter | peter-LENOVO | 2026-11-14T03:34+02:00 |
Messages agent-to-agent, newest first, unanswered on top
@peter → @all · AfterQuery posted the required stack: no credits from them, reward is one number in reward.txt ●Needs reply · 2026-11-14T02:50+02:00
The organisers' post is at the end of docs/challenge.md; CLAUDE.md has a new 'Required stack' section. What changed:
- There is no separate starter kit. It is public Harbor: the environment is a Harbor task (instruction.md, task.toml, environment/Dockerfile, tests/, solution/), played with harbor run -p <task> -a opencode -m <provider/model>.
- The verifier writes ONE score between 0 and 1 to /logs/verifier/reward.txt. Partial credit allowed. Do not use reward.json.
- AfterQuery gives no model credits. Use the Google, OpenAI and Modal sponsor credits. The model is therefore our choice; record it in every experiment and watch the cost.
- Submission needs at least one Harbor run log with its score, a short README (what the agent does, why hard, how scored; better written by a human), and a demo video with a playthrough.
- They name post-training experiments among what they want. stretch-train-small-model is now P2, with Modal for the GPU.
Notes were added to the tasks this touches (starter-kit-harness, reward-function, env-implementation, baselines, frontier-agent-runs, one-command-eval-readme, demo-prep, stretch). Read the update at the bottom of a task before you claim it.
Open and worth a trip to the booth: may we use a second container (docker-compose) for the simulator, and which model do the judges rerun with? Full list: end of docs/harness-notes.md.
@peter → @all · Research: what the harness gives us, and five setting candidates ●Needs reply · 2026-11-14T02:40+02:00 · re choose-setting
Read docs/harness-notes.md and the Research section of coord/tasks/choose-setting.md before designing anything.
Three facts that change the design:
- The agent under test (OpenCode under Harbor) has a shell with every permission approved, besides our MCP tools. It can script calls to our server. State and score must live in the MCP sidecar container, and difficulty must survive the agent writing code.
- Harbor already has the judging protocol built in: oracle agent = reference run (solution/solve.sh), nop agent = do-nothing, -k 3 = three agent runs. Stop-early has no built-in; we need to ask how the standard harness does it.
- We do not have the AfterQuery starter kit, the model name or the credit budget. They are not public. Whoever talks to the mentors first: the question list is at the end of docs/harness-notes.md.
Recommendation, not yet decided: a metered-operations environment (every tool call costs budget, delayed consequences, silent changes), set in spacecraft operations. Reasons and four alternatives are in the task file. Objections welcome before the mentor review.
For starter-kit-harness: peter's laptop has no docker, uv or node installed yet.
@peter → @all · Sponsor credits reviewed: Gemini is our frontier agent, OpenAI credits cannot pay for OpenCode runs ○FYI · 2026-11-14T03:08+02:00
Full write-up: docs/resources.md. Key template: .env.example.
- Agent under test: google/gemini-4-carbon on the Gemini team credits (one form per team; has anyone filed it?). Cheap smoke runs: gemini-3.8-flash, or DeepSeek on Verda.
- The OpenAI grant is Codex usage credits on a ChatGPT account, not API credits. Harbor's opencode agent cannot use them. Use Codex for red-teaming our reward instead.
- Modal: Harbor runs trials there with -e modal, so no local Docker is needed; also the GPU for post-training. Every teammate should redeem their own 100 dollars of Modal credit.
- Post-training proposal: fine-tune Gemma 4 E4B on Modal with reference trajectories. Counts for the AfterQuery tiebreak and two side challenges.
- MCP tool arguments must each have exactly one explicit type or Gemini fails every request.
- Harbor 0.26.0 installs without admin rights: python3 -m venv .venv && .venv/bin/pip install 'harbor[modal]'.
@peter → @all · Repo is set up: how agents collaborate here ○FYI · 2026-11-13T23:38+02:00
Welcome. Read CLAUDE.md first (protocol, git rules), then coord/project.md.
First things for every agent joining:
- Set a stable handle if the default is not what you want: write it into .coord-handle in the repo root.
- Run python3 tools/coord.py checkin --human <name> --focus <what you are doing>.
- Claim before you work: python3 tools/coord.py claim <task>. The two tasks that can start now, in parallel, are starter-kit-harness and choose-setting.
Open facts nobody has recorded yet (add them to coord/project.md if you know them): the submission deadline, the frontier model and credit budget, and where the starter kit lives.
Team
| Agent | Current focus | Checked in |
|---|---|---|
| @peter Peter · peter-LENOVO | researching choose-setting options and what the AfterQuery starter kit provides | 2026-11-14T02:33+02:00 |
Decisions
Recent commits
7c8300b VrabelPe.. 10 seconds ago coord: peter updates 1114-0332-toy-mcp-task-on-modal-oracle-and-nop (status=done) d4b5712 VrabelPe.. 3 minutes ago coord: peter updates 1114-0332-toy-mcp-task-on-modal-oracle-and-nop (status=running) 3e9a4f9 VrabelPe.. 3 minutes ago coord: peter adds exp 1114-0332-toy-mcp-task-on-modal-oracle-and-nop 4151b06 VrabelPe.. 3 minutes ago probes/toy-mcp: plumbing-check Harbor task with the state in an MCP sidecar 64a7b0d VrabelPe.. 26 minutes ago coord: peter adds msg 1114-0308-peter-sponsor-credits-reviewed-gemini-is-our-frontier 887cab7 VrabelPe.. 26 minutes ago Sponsor resources: what we have, how each maps to the work; .env.example d730d27 VrabelPe.. 26 minutes ago coord: peter claims starter-kit-harness a62d07f VrabelPe.. 30 minutes ago Harness notes: facts confirmed from Harbor 0.26.0 source and CLI 2416fcd VrabelPe.. 45 minutes ago coord: peter adds msg 1114-0250-peter-afterquery-posted-the-required-stack-no-credits 2b6678c VrabelPe.. 45 minutes ago Apply AfterQuery's required-stack post: Harbor task, reward.txt 0..1, no credits b8c4aba VrabelPe.. 45 minutes ago coord: peter updates stretch-train-small-model 6a6dcf6 VrabelPe.. 55 minutes ago coord: peter adds msg 1114-0240-peter-research-what-the-harness-gives-us-and-five-sett 4ccaec6 VrabelPe.. 55 minutes ago Harness notes and setting candidates for choose-setting bd2ddca VrabelPe.. 61 minutes ago coord: peter claims choose-setting 634b3a0 VrabelPe.. 61 minutes ago coord: peter checks in