Both illustrate how decomposing complex tasks across specialized agents can address problems that monolithic models handle poorly.

Workspace agents can gather context from the right systems, follow team processes, ask for approval when needed, and keep work moving across tools.

But the real power of agents comes when they can work as a team. Instead of lone-wolf bots carrying out single tasks, such as using a browser to make a restaurant reservation or sending you a summary of your inbox, new tools can yoke together multiple agents, give each of them a different job, and orchestrate their behaviors so that they all pull together to complete more complex tasks than an individual agent could do by itself.

The capability rankings reshuffled completely across tasks. There is no stable best model across cybersecurity tasks. The capability frontier is jagged.

It maintains 97% skill compliance across 40 complex skills on MM Claw, each skill exceeding 2,000 tokens.

The 66.6% medal rate on MLE Bench Lite, achieved autonomously over 24 hour windows, tells you something real about how this model behaves when you give it a hard problem and step back.

Corporate Lawyer: Force Majeure Under Executive Order... Management Consultant: 2026 Capital Budget Allocation... Investment Banking Analyst: KVUE DCF Update

we may see a growing divergence between the capabilities we can measure and the capabilities we actually care about.

If this pace of progress continues — doubling task length every six or seven months — we should expect LLMs capable of completing week-long tasks some time next year, and month-long tasks in 2028.

this behavioral shift does not compromise performance on straightforward problems, it might affect performance on more challenging tasks.

Overnight, agents can do maybe 200 human hours of work, but only for very agent-shaped tasks, so researchers need to deliberately sequence projects such that very long tasks suitable for agents happen overnight.

Four levels of shared control can be distinguished [1]: strategic (e.g.,setting a destination), tactical (e.g., doing a specific maneuver like merging into a lane), oper-ational (e.g., maintaining a certain distance from another car), and execution (lowest-level ofcontrolling locomotion, steering, and so on).

Control does not need to be either/or like in many semi-autonomous vehicles.

When two agents sharing control have asymmetric capa-bilities, both loose and tight rein control should be available.

First, control can be shared via an extensionthat allows a machine to amplify human ability.

When riding a horse, the rider communicates high-level information (e.g., the goal) to thehorse but must be ready to guide the horse at a lower level. When the horse knows what to do,for example, if the route is familiar, the rider may not need to engage in low-level control. Thisform of control, called loose rein control, is possible if the horse knows what the rider wants.

First, communication is vital for sharingcontrol, and this can happen at different levels; second, both agents must have internal modelsof each other to understand what those communicative acts mean.

Shared control is about carrying out a task together with a competent partner [1, p. 511]:“In shared control, human(s) and robot(s) are interacting congruently in a perception–actioncycle to perform a dynamic task that either the human or the robot could execute individuallyunder ideal circumstances.”

The question of shared control is timely; semi-autonomous vehicles are only partiallyautonomous. They need the human to assist them and, therefore, some way of handing controlover to the human driver. They also need to have guidance from the driver, for example, onthe choice of route.

An example of such control sharing is powersteering in a car: The car provides additional work to allow the driver to turn the wheels withless effort. An HCI example is mouse acceleration, which allows a user to move the cursor on thescreen farther than the physical movement of the mouse.

Second, control can be shared via relief, which means that the overall burden on the humanis reduced by the machine. An example is automatic shift transmission, which relieves the driverof the task of changing gears in a car. An HCI example is text entry using autocomplete, whichprevents the user from correcting typing mistakes as they type.

Third, control can be shared via partitioning. In this case, a task is decomposed into parts thatcan be addressed by humans and machines separately. An example of such control sharing is semi-automatic parallel parking, which provides the driver with some braking ability while the machinecontrols the speed and steering of the car. An HCI example is automatic spell checking, where thesystem detects and highlights incorrectly spelled words but does not change them. Instead, theuser has to take an explicit corrective action, such as selecting a misspelled word and choosing analternative.

Successful time-sharing depends on the strategy and difficulty of the task in terms of tempo-ral constraints—how many tasks are processed in a given interval—and task complexity—thequantity of information that needs to be processed for a given task.

The first is called thesingle channel theory, which posits that there is limited capacity in the human information pro-cessing system in a time-sharing scenario. When the channel capacity is exceeded, multiple taskstransition from parallel processing to serial processing.

The third theory is information processing analysis theory. Ifat least one task can be carried out automatically, the other task can be carried out with little orno impact on performance (at an appropriate time–error trade-off point).

The second theoryis the multiple resources model, which states that resource limitation concerns the entire systemrather than a channel (Chapter 5).

Second, tasks canbe shared in terms of control, which means that some control over the tasks is assigned to anotheragent, such as another user or a machine.

Ingeneral, perfect time-sharing with no degradation in performance occurs only for tasks that areautomatic, such as speaking while walking.

First, tasks can be time-shared, which implies that the user performs multiple tasks.

Eye-typing forces users to think in terms of individual letters. This has a cognitive cost and is not a fluid means of communication.

To use such a switch for typing, the SGD interface must be designed with this in mind from the beginning. The most common solution is a scanning keyboard.

TTF refers to the ability of technology to support a task [197]. The capabilities of the technology should match the demands of the task and the skills of the individual; in this case, the fit is perfect.

A system may be usable for some tasks and less usable for others; it may be usable for some users but not for others.

Usability concerns how easily computer-based tools may be operated by users trying to accomplish a task. Usability differs from utility. Usability concerns whether users can use the product in a way that makes it possible to realize its utility; utility is about whether the goal is important to the user.

The utility of an interactive system concerns its match with the tasks of users. If the match is good, the tool has high utility; if the tasks that users want to do are not supported by the tool, the tool has low utility.

Users actively repurpose tools to make them more personally usable and relevant. Design should support such repurposing. For example, Renom et al. [696] conducted a study on text editing using a novel user interface. They found that exploration and technical reasoning facilitate creative tool use. Users who explore available commands in a tool are better at repurposing its functionality. More surprisingly, engaging in technical reasoning (reasoning about functionality and objects) supports repurposing more than procedural knowledge inherited from other software.

I’m already finding better ways to batch my tasks. Making smarter to-do lists that include more context

Sub tasks are just issues with a parent issue. When displaying them, always display the ancestor crumb trail.

Marking an issue as as a subtask of another. Having task lists in a description is a great start, but it doesn't help (AFAIK) navigating from child back up the chain to parent. Creating umbrella issues is a very common way to track the top-level focus areas for a release.

subtasks would give insight into how long it will take!

One of the reasons that some projects don't use Gitlab's issues and use an external tracking platform is the lack of issues relations. Without relations issues are just flat, no way to actually track progress of big features. No way to create a "meta" issue that depends on 4 other or create subtasks and so on. The same problem exists on Github too. It would surely make a difference if Gitlab offers a full features tracking issue, instead of just flat issues. Relations is a major first step towards that.

You can now search for tasks using task: similar to block:. There is also task-todo: and task-done: which will match only the tasks that are incomplete or complete, respectively. Use task:"" to match all tasks.

Task lists [x] can now contain any character to indicate a completed task, instead of just x. This value can be used by custom CSS to change the appearance of the check mark, and is also available for plugins to use.

These are sequential because build:ssr imports the public/index.html that build:dom produces.

wordepicture association judgment task

xperimental condition

For example: I wanted a way to add recurring tasks to my list, so I wrote a simple bash script called goodmorning.sh. It uses the command prompt client to quickly add a bunch of tasks to my todo list of choice. I run this script first thing in the morning every workday, and I like it better than any built-in system I’ve found for recurring tasks, because it’s fully under my control.

the activities the participants claimed they used a computer to complete during their average day.

A fundamental task for public philosophy is to attend to the work the public is doing in developing its own self-conception.