What Qwen3.7-Max's '35-Hour Autonomous Run' Means in Practice — Design Notes from an Indie Dev Running Both Antigravity and Claude Code

What 1,158 tool calls actually says about design

The most useful number in the Qwen demo isn't 35 hours — it's 1,158 tool calls. At one call per ~70 seconds for a day and a half, most of those calls must have been failures, partial successes, and retries. The Qwen team explicitly notes that the model "kept its optimization strategy across more than a thousand tool calls and continued to find meaningful improvements past 30 hours."

Three design principles fall out of that:

1. Don't throw failures away. Failed runs should feed the next call as input, not just clutter logs.
2. Carry a policy memo. The original plan must be summarized and refreshed across hundreds of calls or it dissipates.
3. Separate the verifier. The agent that solves the task and the agent that decides whether it's solved should not be the same instance.

The third point lines up with how the Qwen team describes training: tasks, environments, and verifiers were factored apart and recombined. When I build agents in Antigravity, I keep this separation explicit.

// Minimal verifier-separated loop (TypeScript)
type Verifier = (artifact: string) => Promise<{ passed: boolean; signal: string }>;
 
async function autonomousLoop(
  task: string,
  tools: Record<string, Function>,
  verifier: Verifier,
  policyMemo: string,
) {
  for (let step = 0; step < 1200; step++) {
    const action = await planNextStep({ task, tools, policyMemo });
    const result = await runAction(action, tools);
    const checked = await verifier(result.artifact);
 
    policyMemo = await updatePolicyMemo({
      previous: policyMemo,
      lastAction: action,
      lastResult: result,
      verdict: checked,
    });
 
    if (checked.passed && checked.signal === 'final') break;
  }
}

That policyMemo slot is the same shape I use in the Lacrima and Mystery publishing pipelines. Surviving 1,500 tool calls demands "don't discard the summary" and "verification belongs to a different actor."

How I split work between Antigravity and Claude Code

I run both Antigravity (Google) and Claude Code (Anthropic). With the long-horizon class of models rising, I split work on three axes:

A model that genuinely behaves the same across environments lowers lock-in risk for indie developers. If Qwen3.7-Max delivers on that claim, I'll add it on both sides of the table by calling it once as a Claude Code-compatible API and once as an Antigravity Subagent, then comparing notes.

That said, after three months of running the two side by side, my pragmatic line is: tasks that mix local files with frequent human prompts go to Claude Code; cloud scratch builds and parallel work go to Antigravity. New models inherit that split until evaluation says otherwise.

Building an MCP-Mark-shaped evaluation set on your own repo

You can't directly reproduce MCP-Mark or MCP-Atlas, but you can build the same shape on your own work:

1. Tasks — ten repo-local, fully specified tasks (e.g. "extract MDX from content/articles/ja/agents/ that matches condition X")
2. Execution environments — Claude Code (local), Antigravity Subagent, OpenAI-compatible API direct
3. Verifier — diff the JSON output against an expected file and score mechanically

for env in claude-code antigravity openai-compat; do
  for task in tasks/*.json; do
    result=$(./run_task.sh "$env" "$task")
    ./verify.sh "$task" "$result"
  done
done > eval-$(date +%Y%m%d).log

Run this once a month. When a model like Qwen3.7-Max appears, you already have the harness to grade it against your real workload, instead of trusting the marketing numbers.

A back-of-envelope cost simulation for a solo developer

What does 35 hours of autonomous execution actually cost? Specific Qwen3.7-Max pricing isn't public yet, but my own publishing pipeline gives me a baseline.

• Each article uses ~8,000 input + ~6,000 output tokens
• 4 articles/day × 4 sites = 16/day, or about 480/month
• Monthly token spend: ~6.7M input + ~2.9M output ≈ 9.6M tokens

At Claude Opus 4.6-class pricing (hypothetically $15/M in, $75/M out) that puts monthly tokens at roughly $100–$330. A new model at 1/10 the cost for comparable performance is a $1,000–$3,000 annual delta — which is a serious lever for a one-person business. The recent ITmedia coverage of Cursor Composer making "frontier-class performance at 1/10 the cost" assessed by a third party sits in exactly this same conversation.

Closing — how indie developers should invest "autonomous hours"

As long-horizon autonomous models become common, the time design of an indie developer shifts. The old game was "how dense can you make the hours you're awake?" The new game adds "how much good autonomous work can you queue while you sleep?"

When I started teaching myself code in 1997, the only "thing that ran while I slept" I could imagine was a long compiler build. Today, Claude Code checks voice personalization overnight, Antigravity sorts next week's article candidates before dawn, and by morning I'm the one evaluating, not generating. That's a different kind of work, and it rewards different investments.

The 35-hour, 1,158-tool-call demo from Qwen3.7-Max maps onto a useful question for the rest of us: "can I queue three or four long-horizon tasks between sundown and sunrise without losing sleep?" The smallest next step is to write one evaluation task for your own repo today. One task is enough — once it exists, every new model gets a fair, repeatable read against your real work.

Thanks for reading.