Blog / WEEKLY #001
Weekly #001 | The LLM “Kill Line” Wars: Tokens Are the New Money
Flash off-the-shelf firmware, rework the interface into Chinese, bolt on a voice output path, and a small desktop dev board goes from toy to an assistant terminal that gets used every day; as for taking over the whole house, that is still just a vision.
Phone performance is already more than enough, yet an Agent can barely access anything on it: from permissions and sandboxes to app isolation, the mobile bottleneck lies beyond raw compute.
Moving plugins from one agent to another, format conversion is no longer the hard part; the real threshold is that each platform exposes different capabilities, and upstream keeps changing fast.
Projects, caches, system images, and raw video fill the drive together. The question is not only how much capacity to buy, but which data is worth keeping, on which tier, and whether it can be found again when needed.
Whichever service holds your memory is the one you have to ask for it back when you switch tools. A file system you own lets personal context move between multiple agents — but sync, backup, and multimodal material are still unfinished roads.
The ceiling of what a life assistant can do often is not the model — it is where the information it can see lives: the same school notice is readily at hand in email, but hard to reach inside a group chat.
Resale discounts on model APIs keep thinning; profit has to be earned by turning tokens into usable services. This article maps the cost structure of AI applications and the opportunity in "experience arbitrage."
Whether logins, software, and files survive after a task ends is splitting agent execution environments into two generations. Persistent environments make scheduled tasks and long-running collaboration possible — and push cost and multi-machine management onto the user.
Once visuals can generate in real time and shots can be produced in bulk, the real gap moves from "does it look real" to "does the story hold up." Authorship, serialization, and audience response decide how far this kind of content can go.
Once the barrier to creation has fallen so low, how a work actually reaches its audience becomes the new bottleneck. Distribution does not happen automatically just because something is well made; it needs to be designed and validated in its own right.
Models keep getting faster and code keeps getting cheaper to write, but the speed at which software reaches users has not automatically caught up. Between individual output and organizational delivery sits a whole set of steps that have yet to be redesigned.
When an agent needs to connect to a new service, should the user tap once to authorize, or go apply for an API key themselves? The difference in that one small step separates two generations of product design.
Buying an always-on machine does not mean you have to run models on it. This article pulls apart three needs — local inference, an always-on device, and privacy control — and judges when each is worth adding to your own setup.
Beyond leaderboard scores, a model's real performance depends on the runtime framework, the type of task, and how fresh the test data is. Using concrete tasks as examples, this article explains how to read evaluation results — and how to use them.
Recording, editing, platform uploads, and the website transcript used to be separate manual chores. When the steps beyond writing code can also be handed to an agent, the most human-intensive part of the pipeline shifts from operating to deciding.
The basic execution capabilities of an agent are being taken over by managed services and mature frameworks. The question an application team has to answer is not whether to build in-house, but which responsibilities to hand over and which to keep.
After the prompts are tuned and the pipeline works, model behavior can quietly shift one day. This article breaks the "models got dumber" debate into separate questions: versions, routing, pricing, and compatibility.
Once model prices fall, the first thing to change is not the capability rankings but which tasks become worth handing to a model. This article maps how cheap models expand usage, and how they divide work with frontier models.
