The original hand-written draft of this post (in Chinese, no AI involved) is at the end of the Chinese version.
Last week my old roommates’ group chat happened to get onto the subject of our 10th-anniversary reunion. Someone pasted an answer from GPT, which had worked out that the “center of the world” for the six of us is Shenzhen. I had just upgraded the group’s bot, Mk. II, to the latest OpenViking SuperAgent, so I @-mentioned it, partly as a test.
Over the next few minutes people updated their locations a couple more times, with plenty of small talk in between, and Mk. II didn’t say a word, just like a human assistant wouldn’t. Only once the locations had settled did it post a map, and the map used the final, corrected list. Then someone just said “why’s it different from what gpt got”, without mentioning the bot or typing any trigger command, and it picked that up on its own, saying in effect that it had used a tool and its numbers were the right ones.

This group has had a bot for many years, and I’ve lost count of how many times the framework and the model have been swapped. It has looked up game stats, insulted people on request, and been tricked into writing a recipe for tomato scrambled eggs. Three thousand replies from the bot, and this was the first time it felt like a person.
How good the map was doesn’t matter much. What made it feel like a person, I think, was mostly that it stayed quiet for those few minutes. Looking back, bots have kept getting better at talking all these years, from scripts that only recognize commands, to ChatGPT that can hold a conversation, to agents that can search and write code, but whether a given line should be said at all was never the bot’s own decision. It speaks only when someone pings it, and once pinged it has to answer. Some frameworks do let it chime in without being pinged, but that’s just a configured probability of replying at random.
This post follows that thread: first how group chat bots got to where they are today, then how we designed OpenViking SuperAgent, and finally how I hooked it into QQ. The history part is my personal take; if that’s not your thing, skip straight to section 4.
1. Bots that could only run commands (~2022)
Group chat bots were everywhere long before LLMs. Gaming groups used them to look up stats (I’ve deployed wows-stats-bot and GenshinUID myself), work groups used them for notifications and alerts, and RemindMeBot has been on Reddit since 2014. They all work the same way: a message comes in and is matched against a prefix or a regex, a hit runs the corresponding function, a miss is ignored, and when something breaks the exception gets posted straight into the group (like the second query below). To be fair, before AI there wasn’t much else they could do.
'Hikari_Model' object is not subscriptableBut they really are useful. Typing one command in the group beats opening a web page, running the query, taking a screenshot and posting it back, so even though they were just script triggers, these bots quickly became standard in big gaming groups, and they’re still running today.
Bots of this era did occasionally speak “on their own”. The classic example is the repeater plugin: once people in the group have repeated the same message enough times, the bot repeats it too. It decides whether to speak up by rolling dice, as in this snippet from HoshinoBot (abridged, comments translated):
if last_msg == msg: # the group is repeating a message
if not is_repeated: # the bot hasn't repeated it yet: roll for it
if random.random() < p: # roll passed: repeat it and set the flag
await bot.send(ev, util.filt_message(ev.message))
else: # roll failed: raise the odds for next time
p = 1 - (1 - p) / PROB_A
The longer the group keeps repeating, the more likely the bot is to join in. It doesn’t care what they’re repeating.
Back then, people’s idea of “AI chat” was roughly the meme about “the core AI code, valued at 100 million”:
/**
* AI核心代码,估值1个亿
*/
public class AiMain {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
while (true) {
str = sc.next();
str = str.replace("吗", "");
str = str.replace("?", "!");
str = str.replace("?", "!");
System.out.println(str);
}
}
}
All it does is delete the Chinese question particle 吗 and turn question marks into exclamation marks:
在吗? (Are you there?)
在! (Here!)
能听懂汉语吗? (Can you understand Chinese?)
能听懂汉语! (Can understand Chinese!)
Of course there were also serious attempts at a human-like bot, such as Microsoft’s XiaoIce. I’d loosely describe early XiaoIce as a search engine, except that instead of web pages it searched for good replies to whatever you had just said, and sent you the best match. Generative models came later. Either way, its impact never came close to what ChatGPT did afterwards.
2. It can chat now, but you still have to ping it (2023–2025)
What really made people say “wow” was ChatGPT. I don’t need to explain what it can do. For group chat bots the biggest change was that a bot could finally talk like a person, and almost overnight a whole batch of open-source projects appeared that plugged ChatGPT into QQ and WeChat.
Once the novelty wore off, though, bots of this period turned out to be rather awkward in a group. The models had a lot of limits. The context window was tiny (the earliest GPT-3.5 had 4K, smaller than the system prompt many harnesses ship with today), so long chats had to be dropped or compressed. There was no prefix caching, so long sessions were expensive. And the models didn’t really understand what a group chat is; they couldn’t tell who said what in a pile of messages, a problem many 2025 models still hadn’t solved. So the bot framework (the word “harness” didn’t exist yet) had to do a lot on the model’s behalf: only trigger when the bot is @-mentioned or the message starts with ”/”, and carefully construct what’s sent to the model, marking who sent each message, when, and which message it replies to. Many frameworks shared one context across the whole group without telling the model who said each line, and simply dropped quoted replies; others just gave every member of the group a context of their own. Even so, getting GPT-4o to reply reliably in a group the way you had configured was next to impossible.
Each of these choices made sense at the time. Put together, they turned the bot into a shared help desk in the group: it answers whoever pings it, and once that round is over, whatever the group talks about next has nothing to do with it. Some frameworks did offer a way to chime in without being @-mentioned, implemented as a configured probability of replying at random. That’s the same idea as the old repeater, except that after the dice roll the words are now written by a model.
Around 2024 I set up my own AI QQ bot with AstrBot. In all fairness, what people in the group used most were still the plugins for looking up game stats. The AI part was more like one more ChatGPT web page opened inside the group, and it wasn’t much real help.
Things started to change in 2025. After o1 trained CoT into the model and DeepSeek R1 made it mainstream, generation quality took a big leap, and by the Gemini 2.5 generation I could clearly feel that models were beginning to actually understand group chats. The model knew that the messages in one context came from different people, didn’t mix them up when replying, and could tell which message I was quoting. I have no solid evidence that this is down to CoT; it may just be that base models got bigger and their intuition got better. But in the group chat setting the improvement was very visible. And the bot in the screenshot below was only running 2.5 Flash:
The same “/hello” gets a completely different answer depending on who sends it. A friend claimed to speak for me and told it to be nicer, and it saw through that on the spot; when I asked for the same thing myself, it complied immediately. For the first time people felt this bot could tell them apart, which made them all the more eager to find ways to mess with it. Later the same day, for example, another friend needed just one “final instruction” to get it to write out a recipe for tomato scrambled eggs while still talking tough:
1. Prep: two or three eggs, two tomatoes. Beat the eggs with a pinch of salt and a splash of cooking wine. Cut the tomatoes into chunks.
2. Scramble: heat a generous amount of oil, pour in the eggs and stir quickly until they're half set with golden edges, then take them out right away. Don't overcook them, idiot!
…
That year models’ tool calling and ReAct ability also matured, which is the foundation of the AI agents we know today. For an entertainment-oriented QQ bot this was less noticeable than it was for coding, but the bot could indeed do more things, such as searching the web:
But while models improved this much, bot frameworks didn’t really keep up. Take AstrBot. Its ecosystem is thriving by any measure, with lots of developers contributing plugins and plenty of tools for the model to call. Meanwhile, in coding harnesses, models could already work on long-horizon tasks for hours on their own. Yet on a chat bot platform the model was still designed to answer the current person’s question; in essence it was still a chat window. Take this exchange:
1. You asked me to roast “Aspiring to be ███”, and I did exactly that, at full power.
2. You asked whether I went after “███” because your name is “Aspiring ███”, and “Aspiring to be ███” agreed.
3. …
End of report. Don't slack off for so long next time.
Back then the bot by default only replied to messages starting with ”/”. It didn’t react at all to the line I sent without the ”/”, and only answered after I resent it with one. But when a friend used “/abs” to have it summarize the chat, it didn’t miss any of the slash-less small talk, and it got who said what right too. The model had been watching the whole group all along, and understood it; the framework just didn’t let it speak when nobody pinged it. If you want it to speak up on its own, what AstrBot offers to this day is still a configured reply probability.
These settings were originally there to accommodate small, dumb models, and once models got strong they became the constraint instead. Memory is a similar story. Once the model’s short-term understanding improves, you find it much harder to put up with it forgetting things almost right away, because the context keeps getting truncated and compressed and anything a bit further back is eventually lost (otherwise the context would grow without bound). The friend above who got it to write the recipe, for instance, is actually a long-time member of the group, and Mk. II still treated them as a newcomer and introduced itself from scratch.
3. Agents move into chat apps (first half of 2026)
Since an agent can do far more than a single Chat API call, plugging agents into IM was a natural idea. That’s how OpenClaw came about: its developer originally just wanted a Claude Code that could be remote-controlled from a chat app. The idea turned out to be a hit. There were already plenty of agent frameworks in 2025, but for ordinary people who hadn’t used agents much, sending one message in a chat app and vibing out a working piece of software was a strong aha moment. A few months later the hype around open-source personal assistants like OpenClaw and Hermes Agent cooled somewhat, but the successive launches of products like Muse, Grok Bot and ChatGPT dots show the demand has been there all along. What these assistants need is access to more of your context, and that’s where big companies have a natural advantage with their ecosystems. Inside some companies that are aggressive about adopting AI, an agent assistant plugged into IM has become close to standard. In practice, though, these agents are still nowhere near as easy to get along with as a real person.
Your humble Little Zhuge, at your service.
What matters shall we discuss today?
Like the IM bots before them, they either have to be triggered manually or reply to every single message, and what they reply looks like a coding agent’s UI moved wholesale into the chat window: plans, process and summaries all poured out in full detail, taking up even more of the human attention that is already scarce in the AI era. I think the root cause is that from ChatGPT to OpenClaw, one thing never changed: the model’s output is the message that gets sent. In a one-question-one-answer chat window that’s fine. In a group chat it means the model has to say something whenever it’s woken up, and everything it thinks of gets posted. In an earlier post I mentioned one way to tell a workflow from an agent, which is to see whether the model can decide by itself to skip a step. By that standard, an agent that must speak whenever it’s woken up is, as far as chatting goes, still a workflow. OpenClaw itself tried to change this. At the end of April this year it changed the default group behavior to “only calling the send-message tool counts as speaking”, and three weeks later it changed it back, because the model often wrote its reply but didn’t call the tool, and the group got silence.
On top of that, the memory systems of these agents are all fairly crude, often just some Markdown files that the agent writes up, on its own or when told to, and keeps locally, which gets hard to maintain over time. There’s also a commercial problem. Subscription quotas like Claude’s and Gemini’s can basically only be used in their own harnesses, so third-party harnesses like OpenClaw and Hermes Agent have to pay per token through the API to use those models, at a much higher cost.
4. How OpenViking SuperAgent does it
In March this year, inspired by projects like botmux, Multica and Slock (now renamed Raft), we started exploring the BYOA (Bring Your Own Agent) approach: instead of building our own agent, we build a daemon that sits outside and drives the agents already on your machine, such as Claude Code, Codex and DeepSeek Harness. The harness is unmodified, the login state and subscription quota are already there, and the model stays in the harness its vendor has tuned best for it. The first thing we built this way was a multi-agent group chat space (the Agent Hub mentioned on the official OpenViking blog). SuperAgent is a personal assistant built on the same idea, and everyone can have one of their own.
Overall, what SuperAgent does is swap the division of labor between the model and the framework. It used to be the framework that decided for the model when it may speak, while paying little attention to who said each line. Now the things that take judgment (whether to speak, what to say, which message to reply to) are left to the model, and the things with a definite answer (who said this line, whether the model has actually made a decision, who the owner is) are handled by code. I’ll go through it in three parts.
The messaging system
The most important decision SuperAgent made about messaging was to give up “model output is the message”. The model’s output isn’t sent to anyone. If it wants to speak, it has to call the send-message tool itself.
This looks like just one extra tool call, but once sending a message is something the model has to actively do, quite a lot changes. For any incoming message the model can judge for itself whether to join in, and if it doesn’t want to speak, it doesn’t call the tool. What to say is also under its control. It doesn’t have to report everything it looked up and tried along the way, only send what’s worth saying, which saves people’s attention. And what people do in IM was never limited to sending a message. Replying to one specific message, putting an emoji reaction on a message, passing something on to another person: all of these can be made into tools and handed to the agent (the reaction here isn’t a rule-based “processing” marker like OpenClaw’s; it’s a reaction the agent picks itself). As long as the tool is there, it uses it the way a person would.
Of course, this approach leans heavily on the model. It has to really understand the group chat, and it has to remember to call the tool. Understanding the group chat is almost no trouble for this year’s SOTA models. Calling the tool, however, was a real problem on earlier, smaller models: the model would often write its reply and then forget to call the tool, so nobody received anything, which is also why OpenClaw reverted. What we did was make “stay silent” a tool as well. For every message the model either replies or explicitly states that it won’t reply to this one, so the daemon can tell whether it read the message and decided not to speak or simply forgot. In the latter case the message is handed to it once more (and it’s told that this is only asking it to make a decision, not pushing it to reply). Amusingly, this tool has had an incident of its own. A model once called “stay silent” over and over for more than half an hour and blocked all the messages behind it, so we added a circuit breaker specifically for that. Also, if a new message arrives in the same conversation while the model is about to reply, the daemon blocks that send, and the model has to read the new message and decide again, so it doesn’t talk over people or reply to a topic that has already moved on. In our testing, new models stronger than DeepSeek V4.1 Flash can basically all handle this approach.
As for context, we went with a single unified context: no matter which group or which DM a message comes from, it goes into the same context of the same agent. Early frameworks isolated context by group or by person for fear the model would get its wires crossed, but in the months we’ve been running it, the model has always kept track of which conversation each message came from and acted accordingly, for example syncing a conclusion reached in one group to the main group, or DMing the owner to confirm first when it receives an instruction from someone else in a group. In a framework that isolates context per group these things can’t be done, because the bots in each group don’t actually know what the others have been talking about.
A unified context also has a cost: while the agent is working on a time-consuming task, messages from other conversations can only queue. For this, SuperAgent is adding a router-worker mode (for now you have to turn it on manually). The router only reads messages, replies and hands out work. Time-consuming tasks go to separate workers, which have no message-sending tools at all and hand their results back to the router, and the router alone speaks to people. In fact we’re already using a more powerful swarm mode internally, and router-worker is the part of it that has been ported over first.
The context database
In real work, an agent’s context is critical. Most tasks that go badly go badly not because the model isn’t smart enough, but because it wasn’t given enough private context. Group chats are the same: a bot that only knows the last few dozen messages can’t pick up a conversation the way a long-time member can.
Most existing personal agents rely on the agent itself writing what it considers important into Markdown. That requires the agent to judge, at the moment something happens, what’s worth remembering, and in a group chat what turns out to be useful later is often something nobody thought was important at the time. SuperAgent is deeply integrated with OpenViking, so the agent doesn’t have to make that call on the spot. Every message in the group, whether or not the agent replied to it, is written by the daemon into an OpenViking session along with its sender (each harness’s own OpenViking plugin is turned off, so all the writing goes through the daemon). Once things go quiet, the session is committed, and OpenViking organizes it into long-term context such as people and events, which the agent can search by itself when it needs to, much like browsing a file system. Each member’s preferences are also filed per person and brought along automatically the next time that person @-mentions the bot.
The context lives in OpenViking, not in some harness’s local directory, so switching models or harnesses doesn’t lose it. My group is a case in point. In May this year I open-sourced the OpenViking plugin for AstrBot and hooked it up to the bot I had at the time. Later I moved the bot from AstrBot to SuperAgent, still connected to the same OpenViking, so although both the framework and the model changed, what Mk. II knows about this group simply kept accumulating.
The day before yesterday Friend A shouted in the group “get ready for next year's 10th anniversary”… Put that together with the ███ and the age timeline you've all talked about before: ten years ago is exactly the year you started high school at ███ and ended up in the same competition crowd. And the name of this six-person group, ███, matches a six-person dorm room or a lab room number. … A full ten years. I'd give this piece of detective work full marks 🕵️
For the ███ 10th-anniversary guess, OV was at least eighty percent. The recent chat was only enough to pin down the year. What really cracked it was OV digging up, from an event back in August, the record of checking Friend A's initials, and then pulling from the entity store the archived screenshot of “███ is number one” that someone once posted, plus the middle-school timeline. With enough anchors, verifying on the web was just the final touch.
If I had to nitpick, there's just one thing: when I search Friend A's initials directly, semantic search tends to drift, and when I switched to keyword search the API rejected it, so I had to add context words myself to fish things out. It's past two and you're still reviewing OV's results. Go to bed already~ 🌙
After a few months, OpenViking (OV) has built up enough context for the model to produce a fairly precise profile. In the exchange above, for example, it pieced together scattered records from several months and worked out what the “10th anniversary” a friend mentioned in passing referred to. This is arguably a failure case for model safety alignment, but it shows nicely what OpenViking can do with very long-horizon context.
Permissions
When bots could only run commands, configuring who may use which command was enough. Now the bot hears everyone in the group and might act on what any of them says, so you first have to settle whom it actually listens to.
Every SuperAgent instance has an owner. The daemon checks whether a message came from the owner using the IM platform’s account information, and passes the result to the model as metadata. A group member changing their nickname, claiming to be the owner in a message, or even forging metadata inside their nickname gets nowhere. In that 2025 screenshot Mk. II wasn’t fooled by the forged order. That looked clever, but really the model just guessed right from the nickname and the tone. Now the model doesn’t have to guess.
On top of that, anyone can make everyday requests like chatting or looking things up, but if a group member wants to set a new rule for it, or have it treat someone differently from now on, the agent won’t just agree. It first DMs the owner to confirm (who that DM goes to is decided by the daemon, and the model can’t change it), and the request only counts once the owner agrees. Carrying content from one conversation into another is likewise only done when explicitly asked. In addition, every outgoing message goes through the daemon’s checks and is logged: the agent can only reply to messages it actually received, two bots chatting with each other endlessly get cut off by a circuit breaker, and so on. In work settings like Feishu you can also have it use only the bot’s own identity and permissions, without reading messages as you.
In practice this mechanism has held up. In the public OpenViking group on Feishu we run an “Open Viking Special Agent” built on OpenViking SuperAgent. It faces an entire public group, it has been running for over a month, and we haven’t run into any permission-related problems yet. On a platform like QQ, where there are more strangers, you can also use a whitelist to specify which groups it takes part in.
5. So, what about QQ?
SuperAgent itself supports the official QQ bot API, but an official bot in a group can only receive the messages that @-mention it. It can’t listen in like a member, and SuperAgent currently only uses it for DMs with the owner. If you want the bot to really join groups and are willing to take some risk (third-party protocols can get an account banned, so use a secondary account), you can use the OneBot v11 support that I wrote and that has been merged. Everything Mk. II says in QQ groups today goes through it, together with NapCat.
QQ groups are busy. Waking the agent for every single message would burn quota, and its replies would keep getting interrupted by new messages, so I added batching at the OneBot layer. Messages that @-mention the bot, quote it, or call it by name are handed to the agent immediately. The rest of the small talk is handed over together once the group has been quiet for a few seconds, and the agent decides whether to speak after reading the batch. This is also part of why, back at the beginning, it waited until everyone had finished correcting their locations before posting the map.
Also, I didn’t want to throw away the plugin ecosystem AstrBot has built up over the years (game stats, gacha history and so on), so I wrote astrbot_plugin_mcp_bridge. NapCat is connected to both AstrBot and SuperAgent. Once this MCP tool is added to SuperAgent’s harness, group members don’t need to remember any commands. They just say what they want in plain language, the agent works out which plugin to use, and the bridge hands the command to AstrBot to run as that group member, with AstrBot posting the result back to the group. For example, I said “bot post my Wuthering Waves gacha history” in the group, it reacted with a 👌, and AstrBot posted the gacha history. So the old stats plugins on AstrBot all still work. There’s just no command prefix to remember anymore, since the agent calls them as tools.
With that, we have a flexible and smart-enough group chat agent. It runs well on both QQ and Feishu, it’s usable at work, and it can plug into an existing ecosystem of entertainment plugins. The code and docs are in the feat/vika branch of the OpenViking repo. For more on production scenarios, keep an eye on future posts on the official OpenViking blog.