Qwen 3.8 Max demonstrated something no other model has: 16-day autonomous coding. It built “oh-my-cli”, a self-evolving agent framework, from scratch over 16 days without human intervention. It established an engineering loop with user feedback, community practices, and self-test data, iterating through code generation, testing, previewing, and log analysis.
This is not a benchmark number. This is a real project, running for 16 days, producing real code that works.
What happened
Alibaba tasked Qwen 3.8 Max with creating a self-evolving agent framework. The model:
- Designed the architecture from scratch
- Wrote the initial code for the framework
- Tested the code and analyzed failures
- Iterated based on test results and user feedback
- Incorporated community best practices from external sources
- Continued for 16 days without human intervention
The result: oh-my-cli, a fully open-sourced framework on GitHub.
Why this matters for agent developers
1. Sustained operation
Most AI coding agents work in short bursts: minutes to hours. Qwen 3.8 Max ran for 16 days. That is a 48x improvement over GLM-5.1’s 8-hour autonomous coding demonstration.
For agent developers, this means:
- Long-running tasks are now feasible without human checkpoints
- Complex projects can be completed end-to-end
- Self-improvement is possible over extended periods
2. Self-evolving capability
The model did not just write code. It established an engineering loop:
- User feedback informed direction changes
- Community practices were incorporated from external sources
- Self-test data drove iterative improvement
This is closer to how human developers work than traditional AI coding. The model learned from its own output and improved over time.
3. Real-world production
This was not a benchmark. It was a real project that produced working code. The oh-my-cli framework is open-sourced and functional.
For agent developers, this validates that autonomous coding can produce production-ready output, not just benchmark scores.
Comparison to other autonomous coding models
| Model | Autonomous Duration | Evidence Type | Output |
|---|---|---|---|
| Qwen 3.8 Max | 16 days | Real project | oh-my-cli (open-sourced) |
| GLM-5.1 | 8 hours | Claimed | Not specified |
| Claude Opus 5 | Not demonstrated | N/A | N/A |
| GPT-5.6 Sol | Not demonstrated | N/A | N/A |
| Kimi K3 | Not demonstrated | N/A | N/A |
Qwen 3.8 Max is the only model with a publicly documented multi-day autonomous coding demonstration. GLM-5.1 claims 8 hours but has not published comparable evidence.
Building agents with Qwen 3.8 Max
Long-running task architecture
For tasks that need to run for days:
from dashscope import Generation
class LongRunningAgent:
def __init__(self, task_description):
self.task = task_description
self.history = []
self.iteration = 0
def run_iteration(self):
"""Run one iteration of the engineering loop."""
self.iteration += 1
# Build context from history
context = self._build_context()
# Generate next step
response = Generation.call(
model='qwen3.8-max',
messages=[
{'role': 'system', 'content': 'You are a long-running coding agent.'},
{'role': 'user', 'content': context}
],
result_format='message',
)
# Execute and test
result = response.output.choices[0].message.content
test_result = self._run_tests(result)
# Record feedback
self.history.append({
'iteration': self.iteration,
'output': result,
'test_result': test_result,
})
return result, test_result
def _build_context(self):
"""Build context from task and history."""
context = f"Task: {self.task}\n\n"
for h in self.history[-5:]: # Last 5 iterations
context += f"Iteration {h['iteration']}:\n"
context += f"Output: {h['output'][:200]}...\n"
context += f"Test result: {h['test_result']}\n\n"
return context
def _run_tests(self, code):
"""Execute tests on generated code."""
# Implement test execution logic
passFeedback integration
The key to Qwen 3.8 Max’s success was incorporating feedback:
def integrate_feedback(agent, user_feedback, community_practices):
"""Integrate external feedback into the agent's context."""
feedback_context = f"""
User feedback: {user_feedback}
Community practices: {community_practices}
Based on this feedback, revise your approach.
"""
# Add to agent's context for next iteration
agent.history.append({
'iteration': agent.iteration,
'output': feedback_context,
'test_result': 'feedback integrated',
})Self-improvement loop
Qwen 3.8 Max demonstrated self-improvement through:
- Test-driven iteration: Write code, run tests, fix failures, repeat
- Log analysis: Analyze execution logs to identify issues
- Community learning: Incorporate best practices from external sources
- Feedback loops: Adjust based on user feedback
Limitations
1. No benchmark score: The 16-day demonstration is impressive but not benchmarked. We don’t know how it scores on SWE-bench, Terminal-Bench, or other standard benchmarks.
2. Specific task: The model was given a specific task (build oh-my-cli). We don’t know how it performs on other long-running tasks.
3. Controlled environment: Alibaba controlled the environment. We don’t know how the model performs in uncontrolled, real-world agent deployments.
4. No cost data: We don’t know how much the 16-day run cost in API tokens. Long-running agents can be expensive.
My take
The 16-day autonomous coding demonstration is the most compelling evidence of sustained agent capability we have seen. It’s not a benchmark number. It’s a real project that produced working code.
For agent developers, this changes the calculus. Long-running tasks that previously required human checkpoints can now be delegated to the model. Self-evolving agents that improve over time are now feasible.
The question is reproducibility. Can other developers achieve similar results with Qwen 3.8 Max? Or was this a controlled demonstration with specific conditions? We will know more when the open weights drop next week and the community can test independently.
My recommendation: if you are building long-running agents, Qwen 3.8 Max should be on your shortlist. The 16-day demonstration is unique evidence. But test it yourself before committing to production.
FAQ
Can Qwen 3.8 Max really code for 16 days without human intervention?
According to Alibaba’s documentation, yes. The model built oh-my-cli over 16 days, establishing an engineering loop with user feedback, community practices, and self-test data. The project is open-sourced on GitHub.
How does this compare to other models?
No other model has a publicly documented multi-day autonomous coding demonstration. GLM-5.1 claims 8 hours. Claude Opus 5 and GPT-5.6 Sol have no comparable demonstrations.
Is this reproducible?
We don’t know yet. The open weights are coming next week. The community will need to test independently to verify reproducibility.
How much does 16-day autonomous coding cost?
Not disclosed. Long-running agents can consume significant API tokens. Expect costs in the hundreds to thousands of dollars for a 16-day run.
Can I build similar agents with Qwen 3.8 Max?
Theoretically yes. The model demonstrated the capability. But success depends on task design, feedback integration, and test infrastructure. It’s not just “set it and forget it.”
Should I use Qwen 3.8 Max or Claude Opus 5 for agents?
Qwen 3.8 Max has the stronger evidence for sustained autonomous coding (16 days). Claude Opus 5 has 5-level effort control for fine-grained reasoning. For long-running agents, Qwen 3.8 Max. For controlled reasoning, Opus 5.