Independent reasoning and video evidence — reference patterns

Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.

Extended explanations, comparisons, experiments, and practical actions for the same operating pattern.

Abstract

The strongest reasoning models in this pipeline sit behind chat subscriptions, not APIs. The Oracle tool answers that constraint directly: it drives a real Chrome browser into chatgpt.com and gemini.google.com, authenticated by cookies copied from a profile a human already logged into. This document shows how that works locally in one command, how one operator scales it to an always-on remote pool, why consult prompts must demand a maximum batch of work, and how cheap sentinel probes make fragile video uploads dependable. The evidence is one operator's local records from May–the recorded workflow — about 1,978 consult sessions plus a fully receipted video run. The sources support no claims about cost curves, provider terms, or other people's setups.

Notice where the strongest models actually live

Before you design an agent's "phone a smarter friend" move, check where that friend answers the phone. The easy assumption is an API call. The record here says otherwise.

The Oracle fork's README (S1) states that browser mode targets ChatGPT's latest Pro tier by selecting the model picker's "Latest" row — currently Pro 5.5 with Extended thinking — with no API key involved. 1

1. S1 also lists an API mode with explicit model IDs. But the consult contract (S2) forbids it for this pipeline: every consult must run with the browser engine, and an API-key error means the caller made a mistake, not that a credential is missing. ↩

The video side is stricter. The oracle-video contract (S4) requires Gemini through the browser engine because the file upload happens in the page itself — the API path cannot upload the browser video at all.

So the mistake to avoid is treating "maximum intelligence" as an API shopping question. In this record it is an access question: the strongest text model and the only real video-watching path both sit behind logged-in chat sessions. Whoever holds a valid session cookie holds the key.

Evidence limit The sources describe capability and access, not permission. They do not discuss provider terms of service or account risk, so this document cannot tell you whether the trade-off is acceptable for your accounts.

Explain how an agent borrows your browser

You should be able to say the whole mechanism in one breath, because your audience will ask. Here it is: a human signs into ChatGPT in normal Chrome once; Oracle copies those session cookies into a temporary automation profile; the agent then drives that profile like a very fast reader who pastes a huge bundle of code and waits.

Per S1, first-time setup is a single command run after the human login, and later runs re-read cookies from the logged-in profile each time.

# 1. Sign into ChatGPT in your normal Chrome profile (human, once).
# 2. Let Oracle copy those cookies into its automation profile:
oracle --engine browser -p "HI"

Source: the fork README's macOS browser-mode setup (S1), quoted command verbatim.

What rides along with the cookies is context: the consult skill (S2) bundles project files with a packer and currently validates browser-mode bundles up to roughly 900k tokens. 2

2. S2 phrases this as a target: "Current validated browser-mode bundle target: up to ~900k tokens," with a config knob for files over 10 MiB. The point for a demo audience: this is whole-project context, not a snippet. ↩

The contrast that makes this click: an API integration authenticates as a program and gets program-shaped limits. A cookie-borrowing browser authenticates as you and gets everything the chat product gives you — the model picker, extended thinking modes, and the file-upload widget that the video pipeline depends on.

Evidence limit S1 calls browser automation experimental and stable mainly on macOS. Treat "one command and it works" as the happy path, not a reliability claim; the probe discipline in the later sections exists precisely because this path breaks.

Compare the laptop setup with an always-on pool

Decide which of two shapes you need before you copy anything from this record. Most people need the first one.

Shape one — local: Oracle runs on your own machine and borrows your own Chrome cookies (S1). Setup is the login handshake above. This is the shape the fork README documents for everyone.

Shape two — remote service: S1 documents an oracle serve mode: a signed-in host exposes its browser to remote clients. In this operator's config (S5), every machine points at an always-on Mac mini over a private tailnet; the cookies live once, on that host.

laptop agent ─▶ oracle CLI ─▶ config: remote host + token
                                      │  (private network)
                                      ▼
                    Mac mini: `oracle serve` + signed-in Chrome
                    (cookies live HERE, once, for every client)

Figure 1. Derived display: the remote topology, redrawn from the operator's config structure (S5) and the README's remote-service description (S1). Host addresses and the token are deliberately replaced with placeholders.

Text consults go one step further: the skill's default transport (S3) is a qualified four-slot pool — two ChatGPT accounts, each with two isolated Chrome workers, so four consults run concurrently without sharing a browser profile. 3

3. S3 pins the whole topology — build hashes, ports, tokens — and verifies it before every run, with a FIFO queue where only the oldest waiter probes for a free slot. Those pinned values are private and are not reproduced here. ↩

The decision rule the contrast supports: stay local until concurrency or an always-on machine is the actual bottleneck. The pool's value is not speed of one consult — it is running four twenty-to-sixty-minute consults at once while nobody's laptop stays open.

Evidence limit The pool is qualified against one exact build and topology (S3). The sources give no evidence it transfers to other machines or accounts without redoing that qualification.

Choose prompts that repay an hour of thinking

A consult costs 20–60 minutes of wall clock (S2). The likely mistake is spending that hour the way you'd spend a chat message: "what should I do next?" The contract bans exactly that.

S2's operating principle: every prompt must push toward "the maximum actionable batch" — an ordered set of work packages with exact file, function, and test targets, each carrying a falsifiable verification. Asking for "one next shippable slice" is named as a wasted consult.

What does an archive shaped by that rule look like? In the observed snapshot the sessions directory held about 1,978 consult folders (S5). Table 1 samples real prompt previews.

Session What it asked Oracle to do
actions-parent-lifecycle-third Review iteration 3 of a 12-iteration hardening audit of a Rust/GPUI app
agent-chat-angle-one/-two/-three Verify one commit from three independent angles, in parallel
agent-chat-final-review Judge the three angle-consults against each other and pick the solution
actions-popup-scrollbar-fix Forensic hunt for a scrollbar bug from a user report
agenda-fresh-redesign Produce a full redesign plan for a slide-generating repo
loopcraft-segmentation-review Design the video-sharding strategy that the next section executes

Table 1. Derived display: sampled session slugs and paraphrased prompt previews from the local session archive (S5). Paths shortened; selection is editorial, not random.

Replayability comes with the archive: S1 documents oracle status, oracle session <id> --render, and oracle restart <id>, and each session folder stores the model's full output log (S5).

Your practice, next time you draft a consult: read your prompt and ask whether the answer could keep a local agent busy for hours. If it could be answered in one paragraph, you wrote a chat message, not a consult. Rewrite it to demand the whole ordered batch — targets, snippets, and a verification per package.

Evidence limit The session count and samples show scale and shape of use. The sources contain no measured comparison of consult quality against cheaper prompting, so "repays the hour" is the contract's premise, not a measured result.

Test fragile paths with sentinel probes before spending

Video is where the browser trick earns its keep — and where it is most fragile. Uploads race, model pickers drift, fresh chats initialize slowly. The Loop Craft run (S6) shows the discipline that makes this survivable: never start an expensive analysis on a path you have not just proven with a cheap probe.

The run's goal, from the original session (S6): take a public 93:49 YouTube workshop about the "Loopcraft" durable-agents project and build it into an extensive published wiki with resources, pull quotes, and copy-paste prompts.

A probe is a one-line contract. One real example (S6): "Inspect the attached video itself. Reply with exactly this single line and nothing else:"

ATTACHED_VIDEO_OK loopcraft-awaited-upload-probe

Source: prompt preview of session loopcraft-awaited-upload-probe (S6). Gemini returned the exact line from the real MP4, proving the upload path before any long run.

Time Step Model Outcome
16:39–16:40 First upload probes gemini-3-pro error — path not ready
16:43 Probe after service rebuild gemini-3-pro completed
16:46 Segmentation plan review gpt-5.5-pro completed — shard strategy for the 93:49 video
17:00–18:30 Chunk-analysis attempts gemini-3-pro repeated errors
18:09 Awaited-upload probe gemini-3-pro completed — exact sentinel returned
18:40–18:53 Source-native shards 001–003 gemini-3-pro completed, sentinel-verified
18:53, 19:07 Shard 004 and retry gemini-3-pro error
19:12–19:20 Shard 004, re-encoded gemini-3-pro completed — see next section

Table 2. Derived display: the Loop Craft run of the recorded snapshot, reordered into a timeline from session metadata timestamps and statuses (S6). Times UTC.

The shard analyses show Gemini genuinely watching, not summarizing a transcript: it heard "we are going to talk about Loopcraft…" and identified the GitHub workshop page with the presenter's picture-in-picture at the 00:30 mark (S6).

The signal you are looking for, in your own runs: the sentinel line comes back byte-exact. Anything else — a paraphrase, extra prose, silence — means the path is broken and the long run would have burned an hour to find that out.

Evidence limit Table 2 compresses many sessions; some intermediate error attempts are omitted, and the timeline's "outcome" column paraphrases status fields. The full receipts remain in the operator's local session folders and are not published.

Adjust when a run fails instead of abandoning it

Shard 004 is the teachable failure. Two attempts errored while three sibling shards sailed through, which rules out "the pipeline is down" and points at the input itself.

Per the session record (S6), an exact re-encode of that shard solved it completely: the rich analysis finished in 73 seconds and ended with the exact sentinel. The re-encode settings were preserved as the durable media recipe for future runs.

Publication got the same skepticism as analysis. The agent source-checked pull quotes against the shard analyses, and after publishing it fetched the live pages rather than trusting the publish receipt; both URLs returned HTTP 200 (S6, re-verified S7 in the observed snapshot).

The result is public: the Loopcraft workshop wiki and its video companion (S7) — a 93-minute recording turned into a permanent, quotable artifact in one working session.

The adjustment loop to copy: classify the failure (encoding, not automation), change one variable (re-encode), re-run the cheap proof (sentinel), then keep the fix as a recipe so the next run starts smarter. Deleting the run and starting over would have discarded exactly the knowledge that made shard 004 pass.

Evidence limit The sources record that the re-encode worked, not why the original encoding failed inside Gemini. Treat the recipe as an empirical fix, not a diagnosis.

Practical action

If you want the local shape this record supports, do this, in order. Sign into ChatGPT in your normal Chrome. Run the one-command handshake from the second section and confirm a reply comes back. Then draft your first real consult against the maximum-batch rule: ordered work packages, exact targets, a verification per package. When you move to video, write the sentinel probe before you write the analysis prompt, and do not start the long run until the sentinel returns byte-exact. Keep every session folder — statuses, logs, and failed probes are the dataset your next debugging session will need.

Success signal: your archive starts to look like Table 1 — audits, panels, and plans — rather than a pile of "what next?" chats. Failure signal: consults that finish in minutes with answers you already knew; tighten the prompt, not the model.

Source references