Last month, he told his assistant that "booking a ticket from a window seat, prioritizing a morning flight", and this time he ordered a ticket, does he remember that request?
Recently, DeepSeek introduced four characteristics for the next generation of smart devices in its Super-agent design exploration kit: continuity, efficiency, proactivity, and durability, and argued that "Session should be the implementation detail of the system and not the cognitive burden of the user".
Comma provides a complete engineering implementation: the entire workspace maintains only one main session, maintains a list of facts shared by all Agents using the Jev rapid decision-making model, allows the Agent to write the monitoring process itself, and allocates continuous adjustments to tasks based on artificial acceptance and actual costs.
It is worth mentioning that Comma started on this route earlier. On April 28, Comma's predecessor, Bridge, was released to the public, with the product form being a permanent master agent unified request to receive requests, assigning specific tasks to sub-agents; on June 3, a fixed master dialogue with the task commission was officially launched in the product. As a counterpart, on June 23, Anthropic introduced the similar concept of Claude Tag, allowing the team to share a Claude on the Slack channel. On October 1, Comma was officially released a month earlier than the DeepSeek article.
Figure 1: Comma, Claude Tag and the open timeline of the DeepSeek Super-agent.
The official website:
The code is:https://github.com/AFK-surf/Comma
Tech blogs:
Figure 2: The overall structure of the Comma -- a main session that brings together all the inputs, the Worker performs tasks in parallel, and simplifies the workspace to share current facts throughout the sessions.
Before we go into detail, let's see how Comma works on a daily basis.
Comma sends a worker to write down this little app and directly deploy a preview, where the photos can be fitted with a variety of retro filters:
Figure 3: Show Comma how to make a retro filter app.
On your phone, connected mailboxes, Slack apps, and tasks waiting for you to confirm are all in one place:
Figure 4: Applications that are connected to mobile phones and tasks that need to be handled.
In the past, there was only one main meeting in a workplace.
Comma runs a permanent router for each workstation. Messages from the group chats, chat rooms, and client enters the same session, and the router shares the context between multiple discussions. The specific task is given to an independent worker to execute the session, after which the results and source are returned to the router. Comma calls this design single-session.
In this way, the router always works in the same session and all task results are kept in the same continuous record. When the above context window is full, the earlier content is compressed out of the context of the model and the original record is kept in its entirety: the router can search the original messages and tool results in its history, including the compressed portion, and read back the original.
For example, a user might want to know why they booked a hotel a short distance from a subway station the last time they went to Shanghai. The router can directly retrieve the return of the task at the time, compare the results and execute the record, find the reason and then decide if it will be followed this time.
A single main session also presents a new challenge: the longer the history, the more work required to find a past decision, and the more routers need to process all requests in succession.
Figure 5. Comma client. The left side is the main meeting with the router, and the right side is the tasks and states it sends.
In the same conversation, the user can move on to several things simultaneously. In the following example, the task of "Checking the IP of the local area network and connecting to the air conditioning" is still waiting for the user to fill in the information, the user has then let it see the most recent email, asking what OpenAI sent yesterday:
Figure 6: Deliver multiple tasks at the same time in a conversation.
Keep in mind what, when to update?
Simplified Workspace (Condensed Workspace) is a list of facts maintained by workspace that users can open in the Comma setting. Once opened, each Router and Worker in the workspace has the latest version of this list in the above context, each containing one word.
The list enters the upper context of each session, the input must be reliable, and the outdated content must be updated in a timely manner. Comma passes these two judgments on to the fast-decision model Jev.
Previous post: Article by Article Judging Whether It's Worth Sharing
When an Agent adds or modifies an entry, each article is submitted to Jev as a separate non-subject: does the content belong to current facts that other Agents in the workspace also need to know? Any item that is less than the threshold is likely to be updated and returned to the Agent for final decision by the Agent; it still considers that it should be written and can be submitted again after confirmation.
The questionnaire was subjected to a comparison test. In an artificial labelled sample, a high probability of the correct facts being asked with a reverse questionnaire is that almost all updates will be rejected; a clear gap is drawn between the two categories of content after being changed to a straightforward questionnaire, and the threshold is set in this gap.
After each round of responses: judging whether the list is outdated, whether the work is running out.
Each time the Agent completes a response, Comma combines the current list, recent conversations, and tool calls of this round to ask Jev two separate questions:
Whether it needs to be updated: Whether there are new facts that other Agents need to know in the conversation, such as a decision, a manager, a status, a constraint, or the location of something, while the list is yet to be completed, or whether the statements in the list are outdated;
Whether the agent's recent responses and tool calls contradict the list or user's requests, whether they are repeating failed practices, or whether they are pursuing a goal outside of the conversation.
The probability of "requiring an update" exceeding the threshold, the system will remind the Agent to modify the list; the probability of "deviation" exceeding the threshold, it will remind it to check the current facts and the user requested to check the program.
Returning to the initial example. Users suggested "booking the plane by window seat, prioritizing the morning flight", and when Agent entered the list, Jeff judged that this was a current fact that the work area needed to share, with the entry coming into effect. After that, whether the ticket was booked by the router itself or delivered to a newly built Worker to compare, the request was already in the context.
Figure 7 summarizes two of Jev's judgments in the workspace: shared judgments before writing, and expiration and deviation checks after each round of replies.
What do you know about the group's long-term memory of the team version and IFC?
Simplified workspaces store brief current facts and more complete information stored in the Router's long-term memory, including user preferences, relevant people, working environments, and work logs recorded by date. Long-term preferences, the content the user requests to remember and the progress of the communication, written by the Router during the conversation; and the Worker receives the required information through task communication.
In the team version of Comma for Teams, a Router serves the entire team and receives messages from group chats, private chats, and private channels from different readers.
For this purpose, Comma for Teams uses Information Flow Control (IFC) to control the flow of information: each message identifies who is authorized to read it, the Agent declares which sources are used each time the content is sent out, and the IFC checks whether readers in the target conversation are authorized to read it.
In the team version, long-term memory follows the same rules. Group memory is visible to the entire group, so information from private chats or private channels is written down according to the audience, the range of readers of the notes is determined by the source used when writing. For example, the customer quote you mentioned in the chat, the router will remember to use after delivery, while the replies seen by other members of the group will only show the content they are entitled to read.
Long-term memory is stored as a file and can be viewed and modified directly by the user: the preference is to write too wide; the scope is obsolete and can be modified directly; as required by a fixed rule, instructions can be written to the router.
In the team version, requests between members are also confirmed by each other. In the following example, a Slack colleague asked Comma for Teams to ask another member about the progress of the Comma for iOS, requesting to be sent to the other person first, with the other person choosing to refuse, give it to their own router, or create a task directly:
Figure 8: In the team version, requests between members are first confirmed by each other.
Figure 9 In the team edition of Comma for Teams, long-term memory is written by audience and checked by the IFC before being sent out.
Who's waiting to be delivered?
A lot of work has to wait for external events, such as contract re-signing, code warehousing changes, flight information changes. Comma lets the Agent write a C program for each monitoring, which is compiled into eBPF and runs permanently in the cluster, called a Loop.
Each Loop waits for a timer or event, checks the conditions, and when necessary wakes up the Agent to which it belongs. When semantic judgments are needed, the Loop can pose structured questions to the same decision-making model, Jev, only returning the judgments, and the specific operations and permissions remain in the hands of the Agent.
The program written by Agent runs in the same process as thousands of other Loops, with each program accessing only its own memory, which is a prerequisite for the establishment of an entire set of mechanisms. For this reason, async-ebpf gives proof of machine inspection when Comma's Loop is running: about 40,000 lines of Lean proof establishes that, if compiled into an x86_64 machine code through a validated program, it will only access its own memory and retain the full state of the dial when returned.
Figure 10 shows how the Loop works.
For example, let Comma check the airline's tickets the next day, and it shows the current cheapest flight and returns in card form; the following price changes are given to Loop for continuous attention, and the Agent is alerted to the user when there is a change that deserves to be treated.
Figure 11: A comparison of flights, asking for the lowest price of air tickets for the next day.
Which model will be delivered next?
In addition to recording requirements, Comma will also adjust to which model the task is assigned based on the results of the task.
Each task is assigned to a certain category in the routing table, such as "comparison order tickets" and "sorting out emails". The scheduling layer records the model and reasoning intensity used for each task, the number of times it is completed, and the cost. The completion is determined by whether or not it is approved by artificial acceptance: the task to be audited is accepted, marked as a success; the task fails, marked as a failure.
On this basis, the scheduling layer selects the lowest combinations for each task to be completed on average, and allows a small number of tasks to try other combinations within the model allowed by the team to accumulate a comparison basis. The more records accumulated for each type of task, the more accurate the allocation, and the lower the cost.
Figure 12: Two feedback loops: users modify rules to change things, accept and spend to change tasks to whom they give them to do it.
What is the meaning of this verse?
The continuity, efficiency, proactivity, and durability that DeepSeek proposes describes the direction of the next generation of smart entities. Comma was released to the public about half a year before the DeepSeek announcement and gave its own realization around its "persistence": a main session maintains a complete working record, Jev maintains a list of facts shared by all Agents and continuous verification, long-term memory is divided by audience and modified by users, Agent-written Loop assumes, and so on, and mission scheduling accumulates from each receipt.
For users, what has been changed will be remembered and used, and what is not remembered will be found and modified. As the agent becomes more and more part of the team's workflow, this type of system-level design will determine the long-term effectiveness of the agent as well as model capabilities.
© THE