Three Ways I Tried to Automate 1Point3Acres Daily Check-In and Quiz Answering

1. Direct Codex UI Control

The first design was also the shortest:

flowchart LR
    T["Codex scheduled task"] --> U["Browser UI"] --> S["1Point3Acres"]

Codex directly controlled my signed-in Chrome: it opened the page, read the quiz, selected an option, and submitted it. This was attractive because there was almost no custom code. In my earlier tests, the browser interaction itself could complete the task.

The problem is unattended reliability. Current Codex browser controls may ask before using a website, and sensitive actions can require another confirmation. These are intentional safety boundaries, not application bugs. They are reasonable when a person is present, but a 9:00 a.m. task can stop halfway if nobody is there to approve it.

This does not mean every browser action always triggers a prompt. Permissions may already exist, and behavior can depend on the action. The issue is that I cannot treat approval-free completion as a guarantee. An automation that may pause at the final click is not fully unattended.

Result: this is still useful for an attended task, but I no longer use it as the daily unattended path.

2. Codex with a Local Automation Library

The method I use now has one simple rule: Codex decides; WebContentAgent and the Chrome extension execute and verify. It keeps Codex responsible for the difficult decision but removes browser clicking from Codex itself.

Despite its name, WebContentAgent is not another LLM making decisions in this workflow. Here it is a narrow local library that exposes only the review and browser operations this task needs; it is not a general remote-control tool. A small Chrome extension in my normal Chrome profile reads commands from the local app, uses my existing signed-in session, performs the website actions, and reports the page state back.

%%{init: {'theme':'neutral','themeVariables':{'fontSize':'18px'},'sequence':{'diagramMarginX':14,'actorMargin':34,'messageMargin':28}}}%%
sequenceDiagram
    participant C as Codex task
    participant A as WebContentAgent app
    participant X as Chrome extension
    participant S as 1Point3Acres
    C->>A: Start or resume unfinished daily work
    X->>A: Poll for work
    A-->>X: Check site state and skip completed steps
    X->>S: Act in signed-in Chrome
    S-->>X: Return question and options
    X-->>A: Save exact text and page state
    C->>A: Read frozen review record
    C->>C: Check every option
    C->>A: Approve one option or skip
    X->>A: Prepare approved choice
    X->>S: Select and verify option
    X->>A: Request one-use submit permit
    A-->>X: Return permit
    X->>S: Submit once
    S-->>X: Show grade
    X-->>A: Save explicit website outcome

Figure 3. Codex makes the final quiz decision. WebContentAgent coordinates the run, and the Chrome extension performs and verifies website actions in the signed-in browser.

What happens during one run

Every six hours, Codex checks whether both check-in and the quiz are explicitly complete. An attempt, failure, or consumed permit is not completion. It continues an active run instead of overlapping work. A fresh run rereads the website, skips each completed step, and preserves the exact question and ordered options. An incorrect grade still consumes that day’s quiz attempt; it must not be answered again.

Codex reviews that frozen record and approves one exact option or abstains. The Chrome extension validates approval, selects and verifies the option, and only then claims a one-use submission permit. After submitting, it reads the result without blindly repeating the request. A click, selected radio button, or valid JSON response does not mean the answer was correct; the website’s explicit grade is the evidence.

The Chrome extension polls the app instead of keeping a permanent connection open. The PC must be awake, with Chrome and the required apps running. Checks normally occur about once a minute, but Chrome alarms can be delayed; one minute is not a worst-case guarantee.

Why this is the current choice

This design is not the most autonomous one: Codex remains in the critical path for the quiz decision. That is deliberate. Ordinary code handles time, state, retries, exact text capture, duplicate prevention, and result verification. Codex is used only where judgment is needed.

The safeguards are small but important:

• The app records the exact question and all options before review.
• Codex can skip rather than guess.
• One approval creates one submission permit.
• Old permits are never replayed. An uncertain result is inspected read-only; a fresh run, review, and permit are allowed only after confirming no submission occurred.
• The website outcome is stored separately from both Codex’s decision and any model suggestion.
• Private logs and quiz records stay local.

On a verified run, the website initially delayed the grade. The Chrome extension kept checking the saved run state and later recorded the explicit correct result without submitting a second time. That is the behavior I care about: not merely clicking, but knowing what happened.

Result: this supervised design is the method I use today. It trades some autonomy for a much clearer chain of evidence.

3. Fully Local LLM Automation

The third design asks Gemma to make the quiz decision locally. The evaluated model is Gemma 4 12B QAT (Q4_0 quantization), served by LM Studio. The surrounding browser workflow already runs locally; autonomous answering is the part I am still exploring:

flowchart LR
    A["Local app"] --> M["Local Gemma model"]
    M --> A
    X["Chrome extension"] <--> A
    X <--> S["1Point3Acres"]

The app would schedule the run, the Chrome extension would handle the site, and a local Gemma model would choose the quiz answer. Codex would not participate in the daily path. The model can be loaded only for the quiz and unloaded after five idle minutes, which avoids keeping it in GPU memory all day.

This is appealing: it is local, inexpensive to run, and could be fully unattended. It is also not ready. The difficult failures were not browser clicks; they were failures of evidence and judgment:

• JSON Schema constrains structure and option ranges, but mismatched option text, malformed evidence, and repetitive generation still occurred. Valid formatting does not establish correctness.
• High self-reported confidence did not reliably mean the answer was correct.
• Search results once mixed third-party answer banks with unrelated AI text and gave the evidence a misleading source label.
• A plausible explanation could still support the wrong option—or overlook that “all of the above” was valid.

I have improved the pipeline by requiring structured output, storing every real question and option, separating local-model and Codex decisions, filtering search evidence, and saving the website’s grade. I removed imported community answer banks because they did not preserve all original options. Saved questions are test cases and audit evidence, not an automatic answer key.

Seven recent days: what actually worked?

This audit covers September 19–25, 2026, grouped by the local dates recorded by the app. It uses real-run JSONL records and daily reports, excluding simulations. There were eight real starts: seven explicitly graded submissions and one interrupted September 23 run with no grade, followed by a completed evening run. Check-in was eventually verified on all seven days; that does not mean every start succeeded.

The supervised workflow scored 6/7 (85.7%), not Gemma. Six runs retained a Gemma candidate; five matched Codex (83.3%). Those five submissions produced four correct grades and one incorrect grade, and included downgraded placeholders. On the remaining run, Codex changed the choice and answered correctly; the website never tested Gemma’s candidate. Agreement is not accuracy, and these records do not establish a trustworthy local-only accuracy rate.

A more direct readiness measure is 0/7 local suggestions passing the current evidence gate: one structural failure and six records with evidence_sufficient=false, four of them ending at zero confidence. This model, retrieval, prompt, and validator combination could not independently finish this batch. That is not a claim about all local models. Strict gates can also reject a correct candidate; safe rejection and answer accuracy are different measures.

What remains unreliable?

Three questions need separate answers: Is the output usable? Does its evidence support the option? Is the option correct? September 19 produced invalid option text and evidence entries; September 23 repeated text in the short explanation. Format constraints and validators can reject these outputs without fixing the underlying judgment.

September 25 is more revealing. Gemma gave the correct candidate and 90% confidence, but treated a reply about vague questions and poor independent research as evidence that vague questions receive many wrong answers. A quotation can exist without proving the claim. Self-reported confidence is not a calibrated probability, and Google snippets cannot replace the original post named by a question.

September 22 was a Codex review error. It assembled common-sense guesses into “all of the above” without evidence for a precise forum rule; the website marked it wrong. The user later confirmed option 4, recorded separately as user confirmation—not a website-disclosed answer. A stronger reviewer still needs to verify each option, especially numerical limits and aggregate choices.

Better notes can help without solving the whole problem. After dated, sourced VIP notes were expanded on September 24, one zero-submission replay changed Gemma’s candidate from 1 to 2, but repetitive generation remained. That is a diagnostic lead, not another live success. Model settings, notes, and validation also evolved during this week; this was not a fixed-configuration randomized comparison.

My conclusion: Gemma is currently an adviser to check, not an unattended final decision-maker. The next evaluation should freeze the model, prompt, and retrieval setup, then measure usable-output rate, evidence-gate pass rate, abstentions, and suggestion accuracy on reliably labeled future questions. Website grades and user-confirmed labels should remain distinct. Lowering safeguards merely to raise completion would hide the problem.

Result: I use method 2 today. Method 1 remains suitable when I am present, and method 3 remains an experiment until its accuracy is supported by evidence rather than confidence.

Reference: bugs, fixes, and verification limits

This is a condensed engineering record, not a claim that every issue is solved. Unit tests verify known conditions; local browser tests verify the input path; only the live website grade establishes that day’s quiz result.

The statistics come from private September 19–25 audits and daily reports. Full questions, ordered options, both decisions, failed starts, and replays remain separately recorded; account logs and access credentials are not published. For mechanism background, see Chrome service-worker lifecycle, Chrome alarms, and LM Studio structured output. Those documents explain mechanisms, not this project’s answer quality.