Most of what you've heard about AI scaling laws is about pre-training: throw more compute and data at a model, watch it get smarter. Clean power law, predictable curve, story told. But that's the model before it touches your problem. The question that actually matters if you're building products is how an AI agent improves while it's working. Turns out that has a curve too. ByteDance just mapped it.
ByteDance Seed built EdgeBench, a benchmark designed around a deliberately uncomfortable idea: forget what the model already knows, measure how fast it learns from an environment. They assembled 134 tasks across six domains (scientific research, systems engineering, theorem proving, combinatorial optimisation, professional knowledge work, and games), each requiring between 12 and 72 hours of continuous agent operation. Not 30-second question-and-answer pairs. Real work. They ran five frontier models for roughly 38,000 hours in total and watched what happened.
What they found is a log-sigmoid curve, not the power law you see in pre-training. Performance rises slowly at first, accelerates through a steep middle phase, then flattens as the agent approaches its ceiling for that task. The fit is almost implausibly clean: a mean R-squared of 0.998 across hundreds of averaged learning curves. That's not noise rounding into a trend, that's a structural pattern.
The intuition is elegant. Think of a task as a graph of capabilities, each node either unlocked or locked. An agent's progress spreads outward from what it already understands. Early on, unlocking one thing helps you unlock two more. That's the acceleration. As you approach the task ceiling, you're working at the very edge of your capability graph and each new unlock is harder to reach. Progress slows. The sigmoid shape drops out of this almost inevitably.
Why does this matter? Because until now, agent performance on real tasks felt fundamentally unpredictable. You'd run an agent, watch it stall or suddenly leap forward, and have no framework for knowing whether it was going to plateau or keep climbing. The log-sigmoid gives you that framework. If you can measure where your agent sits on the curve, you know how much headroom is left. That's useful when you're deciding whether to stop a run, how to allocate compute, or whether a given task is even tractable for today's models.
The learning speed finding is worth sitting with separately. ByteDance tracked 18 tasks where models started from similar baselines, measuring two-hour performance gains across releases from September 2025 through May 2026. Frontier agents are getting twice as good at environment learning every three months. Not raw capability in the abstract. Speed at acquiring task-specific knowledge from a live environment. That's a fast curve if you're trying to stay ahead of it as a product builder.
The gravitational-wave detection case study makes it concrete. A single run on LIGO strain data lasted 12 hours, generated 247 scored submissions, and improved from 42.8 to 67.0 on the task metric. Most of that gain came from seven moments of reframing, where the agent stepped back from tuning parameters and restructured its entire approach to the problem. That's not pattern matching. That's iterative hypothesis generation, and it's the behaviour that makes long-horizon agents genuinely useful for hard problems.
For product builders, the practical takeaway is this: one-shot evaluations are nearly useless for predicting agent performance on real tasks. The metric that matters is how your agent improves under load, over time, in your specific environment.
That's the engineering problem we spend a lot of time on at Dakik. Whether you're building a document processing pipeline, a research assistant, or an autonomous operations layer, the decisions that matter most aren't which model you pick on day one. They're how your agent accumulates knowledge from its environment, how you instrument that learning, and how you evaluate whether improvement is actually happening. We build these systems end-to-end: agent architecture, RAG pipelines, vector search with Qdrant, and the evaluation infrastructure to tell you if it's working. We've also written about how the deployment side of this is getting easier (see our post on xAI's Voice Agent Builder and what it signals for the space). The hard part was never getting an agent to run once. It's knowing whether it's getting better.
The full EdgeBench dataset, benchmark tasks, and evaluation framework are open on GitHub and Hugging Face if you want to dig into the specifics yourself.