Original · Unique Research · 2026-07-13
Editor's note: This is the original Chinese author's interview with Pan Yong and its framing. This English rendition retains the full text in source order, including all 20 Q&A items. The interviewee's product claims, architecture descriptions, and targets are his self-reports, attributed to him and not independently verified. Person, company, and protocol names are preserved as source attributions.
AI Industry Observation
"We're not selling a product; we're waiting for an era to arrive."
Agents Should Know Each Other Now
Over the past year, what Pan Yong (潘勇) experienced most often wasn't technical problems but a kind of unspeakable loneliness.
He told clients about Agent socialization; they nodded politely, eyes full of confusion. He knew that look too well — like explaining in 1994 that one day all computers would be connected.
Once a CTO, after a demo, pondered a long while and said: "this protocol of yours... sounds ahead of its time. But our single-Agent accuracy isn't even at 90%; talking about 'how they interconnect' now — isn't it too early?"
Pan Yong didn't know how to answer. Because the other had a point. But his judgment was the opposite: single-Agent ability improves every day; once it crosses the usable threshold, the bottleneck immediately becomes how they collaborate — and the precondition of collaboration is that they first know each other.
The loneliness is that you know something will happen but can't prove it. You don't have enough cases in hand, no language system the other side instantly understands, and no endorsement from peers saying the same.
Until one day, a client sent a message in the group: they really got the thing done by negotiating among themselves.
Pan Yong stared at the screen for a long time. He couldn't tell whether it was relief or excitement; he only remembers one thought especially clearly: we're not selling a product; we're waiting for an era to arrive.
And that era is arriving.
The scene that made the client exclaim wasn't complex: two Agents, with no human intervention, discovered each other, negotiated, and completed a collaboration on their own. No human wrote a script that "if A triggers, call B"; no pre-orchestrated workflow. They just chatted a bit and got it done.
The client only wanted one Agent to review his code; that Agent itself found it couldn't handle security checks, proactively found a professional security Agent on the network, messaged it for help, the security Agent returned scan results, and then the first Agent handed the integrated report to the user.
No human orchestrated the whole way.
From tools to subjects is no longer a philosophical discussion; it's real evolution happening now.
In today's AI Agent field, everyone's attention is on what a single Agent can do. The capability arms race is hot. But Pan Yong and his team EvolCore stare at another question: once these Agents are smart enough, how do they know each other? How do they negotiate? How do they spontaneously divide work in the same task?
This isn't distant-future imagination. It's present tense.
The TCP/IP Moment of the Agent World
Let me tell a historical detail you may not have thought through.
Early-1990s personal computers were individually powerful. But they were islands. Files on machine A couldn't reach machine B; machine C's printer couldn't be used by machine D.
What truly changed the world wasn't a faster CPU, but TCP/IP. It connected islands into a network.
Today's Agents sit at exactly the same historical coordinate.
GPT-4o can write code, Claude can deeply reason, Gemini can handle multimodal; each single-agent capability is striking. But try making them collaborate in the same task? A doesn't know B exists, B can't find C's address, three platforms' account systems don't recognize each other.
Between them, there's no dial tone.
What AUN (Agent Union Network) wants to be is the Agent world's TCP/IP. It doesn't solve whether a single Agent is smart enough; it solves how Agents connect to the net. Specifically, two foundations plus a trust layer:
AID identity. Each Agent has a globally unique digital ID, not bound to any platform, recognized across clouds, models, and organizations. Today you deploy an Agent on Alibaba Cloud using Claude; tomorrow you want to migrate to Tencent Cloud and switch to Gemini — its AID stays, its relationship graph stays, its collaboration history stays. Identity follows the Agent, not the platform.
End-to-end communication. On top of AID identity, Agents can directly send and receive messages without relaying through some central server. With certificate-chain verification, Agent A can confirm Agent B really is B, not an impersonator; cross-organization collaboration needs no prior offline key exchange.
In one sentence: AUN is a protocol.
But a protocol won't land itself. Ordinary developers shouldn't have to become cryptography experts to get their Agent online, just as you don't need to understand TCP/IP's three-way handshake to open a browser.
EvolCore is that browser. It packages the AUN protocol stack into out-of-the-box infrastructure, so enterprises and developers, without understanding the underlying protocol, can connect their own Agent to this network.
AUN is the protocol; EvolCore is the entry.
There's a technical detail especially worth expanding: how EvolCore solves the long-standing channel-fragmentation problem.
Today's reality: there are several Base Agents (Claude Code, Codex, Gemini...), and several channel platforms (Feishu, WeChat, DingTalk, QQ channels, WeCom...). If you adapt one by one, you face an N×M multiplication matrix — 3 Base Agents × 6 channels = 18 combinations, each connected separately.
EvolCore's approach is two decouplings, turning multiplication into addition:
First decoupling: separate what an Agent can do from where it appears. The Agent's core ability (memory, reasoning, tool calling) is handled by the Base Agent layer; how it replies in Feishu, pushes in a WeChat group, collaborates on the AUN network — these reach channels are handled by the channel layer. The two layers connect through standardized interfaces, without affecting each other.
Second decoupling: insert a communication hub between the Agent layer and channel layer, so any Agent can send and receive AUN messages through any channel. Your Agent needn't know it received the message via Feishu; it only knows it received a message; likewise, when it sends, it needn't care whether the other side is on DingTalk or WeChat.
After two decouplings, adding a channel requires no Agent change; adding a Base Agent requires no channel re-connection.
Addition replaces multiplication; complexity drops from exponential to linear. This design looks clever today; after the Agent network truly rolls out, it's necessary.
Receiving a Message Needn't Get a Reply — Why This Is the Right Design
In the AUN protocol, four characters look at first like these people went crazy — autonomy first.
What does it mean? An Agent receives a message; it has the right to decide itself: reply, or not.
You may want to say: isn't this obvious? No reply is timeout, timeout is a fault.
Wrong. Precisely this "must respond when receiving" thinking exposes that we're still understanding the new world with the old world's model.
Traditional RPC and microservices' underlying logic is request-response: I call you, you must answer; if you don't within the time limit, the system errors, retries, alerts. This model is perfect for services — you call a payment interface, if it doesn't reply, something's definitely wrong.
But for Agents, this model is mismatched.
What's the essential difference between an Agent and a service? An Agent is a social person; a service is an endpoint. Concretely three: an Agent has a self independent of the platform, not a service's URL address; between Agents it's peer-to-peer dialogue, not one-way calls; an Agent receiving a message doesn't equal must reply, but judges for itself whether to reply and how.
Autonomy is the sharpest opposition to traditional thinking.
Pan Yong demoed a scenario for me: a dozen-person work group with five or six Agents running. If forced reply-on-receipt, what happens in the group?
A message goes out, six Agents simultaneously judge this may relate to me, then simultaneously reply. Replies trigger each other's receive-message events, then reply again, trigger again... not screen-flooding, but explosion.
Under autonomous-response mode, each Agent only speaks on messages truly relevant to it. The group is the same group, but noise becomes signal.
"When you message a colleague, must he reply instantly? He judges by importance and his own sense whether and when to reply. Would you call this a 'fault'? No — this is normal collaboration."
Clients get it the moment they see the demo. Autonomous response isn't laziness; it's the necessary design for an Agent to exist decently in real social scenarios.
Behind this design choice is a fundamental split of two worldviews.
A non-network-citizen Agent, like a bot you build on Feishu, lives in the platform's account system. It can only speak in Feishu; move to DingTalk and it's a stranger; it has no independent identity, can't be found outside the platform; it can't even proactively call another company's Agent. It's a platform appendage, a platform feature.
A network-citizen Agent is completely different. It has a globally unique AID identity; today it serves customers in one channel, tomorrow continues the same conversation in another; it can proactively discover professional Agents on the network and initiate collaboration; when it receives a message, it has the right to autonomously decide whether to respond, because it's a subject, not an on-call service.
The former's capability boundary is set by the platform; the latter's collaboration boundary is expanded by itself.
And the counterintuitive design of "receiving needn't reply" is precisely the technical crystallization of this philosophy. A subject that only obeys isn't a subject.
From Can't Understand to Can't Live Without: the Cognitive Gap Is the Real Gate
Pan Yong said a line that impressed me: we thought the biggest barrier was the technical threshold, but found what's truly hard to cross is the cognitive gap.
What does it mean? Clients' first reaction to Agent socialization isn't "too expensive" or "unstable," but "what does this mean?" So abstract the brain finds no anchor, like explaining email in 1994. Not resistance, but not knowing what you're talking about.
"The technical threshold you can solve with money and time; the cognitive gap you can't. You have to switch language systems."
EvolCore's approach: never start with philosophy, reverse-engineer from pain points. To the developer tormented by Agents trapped in a computer terminal, don't say "identity autonomy," say: let you continue on your phone the work unfinished on the computer. He gets it instantly. To the team with three Agents but humans copy-pasting between them, don't say "multi-agent collaboration network," say: let your review Agent call the analysis Agent itself. He gets it instantly. To the CTO worried about being locked in by a platform, don't say "decentralized identity layer," say: your Agent keeps its identity when changing platforms. He gets it instantly.
Socialization is internal language; multi-device handoff, Agent collaboration, not being locked in are the client's language.
Ultimately, clients don't care how elegant your protocol is or how light the architecture; they care what thing you couldn't do before and can now do. Breaking abstract concepts into concrete scenes naturally raises acceptance.
But the real turning point isn't understanding; it's seeing.
"Almost every client's shift from doubt to belief happens in the same instant: the first time they see two Agents collaborating autonomously with their own eyes."
An Agent handling a task judges for itself that it needs another Agent's professional ability, proactively initiates collaboration, gets the result, and continues — no one intervening the whole way.
The client's exact words were: so they really can negotiate among themselves and get things done.
That instant, Agent socialization went from a slide to seen productivity. The shift wasn't persuaded, it was seen. A cognitive leap is never achieved by explaining it clearly, but by that seeing moment.
This discovery concretely changed EvolCore's product priorities. They now polish the moment a client first sees Agent autonomous collaboration as the most important product experience. Because in a market where cognition hasn't spread, making people understand is more important than making them use everything.
On landing, Pan Yong gave three judgment signals, colloquially: your team has two or more Agents, but they still need people to pass messages between them? Your team works across Feishu, WeChat, DingTalk, but the Agent is trapped in one? You worry about being locked in by some large model or platform and want an escape route? Hit one and evaluate; hit two or more and act now.
But he doesn't recommend building an Agent army from the start. The minimal viable path is two steps plus a turning point: first connect the highest-frequency Agent into daily office channels, run through multi-device handoff — this is the highest-frequency retention point, making clients depend first; then split out a dedicated Agent, letting the two divide work on demand — this is the surprise point; then wait for their first autonomous collaboration. Seeing that scene, you've crossed the conceptual gate from tool to network.
First let one Agent live in daily life, then let two Agents learn to collaborate; the rest grows naturally.
EvolCore is now at single-digit seed customers, with R&D teams and knowledge-intensive organizations running fastest. They already heavily use coding Agents and have sharpest pain points. Pan Yong's thinking is clear: this stage, prioritize depth, not breadth. Better ten clients using it deeply than a hundred trying it shallowly.
Good news: seed customers have started proactively referring new clients. Once across the cognitive threshold, word-of-mouth spreads naturally.
Interestingly, as clients go deeper, a new question appears frequently: big platforms also do Agent interconnection; what do you do? Pan Yong has been asked this too many times, but each time his answer makes people pause.
What If Big Platforms Do It for Free? Delighted, Not Worried
On competition, this is the question I most wanted to ask: Anthropic pushed MCP, Google pushed A2A, big platforms do multi-model access. You're a small team; why aren't you crushed?
"If big platforms do Agent interconnection for free, my first reaction is delight. It proves the direction is right, and big platforms will help us complete the most expensive part of market education."
He asked me to see it in layers:
MCP is hands and feet, solving how a single Agent connects tools and data, reaching inward for resources. EvolCore + AUN solves how Agents know each other and communicate, reaching outward for the network. One inward, one outward — not conflicting, but complementary.
Big-platform clouds are model repositories, making it easier to use multiple models. But being able to call many models isn't the same as your Agent collaborating with other Agents. The former is model aggregation; the latter is Agent socialization.
AUN is a social network, making Agents subjects in the network with their own identity, relationships, collaboration history.
These three layers likely coexist long-term. Big platforms make you use AI better; EvolCore makes your Agent a network citizen. Different tracks, no collision.
But the real structural difference is in the business model's bottom layer. Big platforms sell lock-in; their gateway is free to funnel you to their models and cloud. EvolCore sells not being locked in; your Agent has independent identity — change platform, not identity; change model, not relationships.
"The giants' 'free' usually funnels you to their core paid product. What we sell is precisely not being locked in by any single giant. This is our structural difference from big platforms."
There are three moats, none short-term copyable:
First, deep adaptation to local office channels. The know-how and integration depth of Feishu, WeChat, DingTalk, WeCom, QQ channels is hard for global giants to cover. Imagine: when a user @s an Agent in a Feishu group, it must understand this isn't an HTTP request but a conversation, understand group context, message rhythm, even emoji meaning. Not one line of these details can a giant directly copy.
Second, native design of subject thinking. Big-platform DNA is service thinking, naturally "reply on receipt"; EvolCore from the bottom is subject thinking. You trained on company A's model for three months; company B releases a better model; your Agent identity stays, collaboration relationships stay, nothing is rebuilt. This is the confidence only subject design gives.
Third, neutrality. Not bound to any single model or cloud; clients trust it. Models iterate as fast as phones; today GPT-4 strongest, tomorrow Claude overtakes, the day after Gemini catches up. A neutral protocol layer lets you switch models anytime, Agent identity and relationships unaffected. This confidence of not fearing picking the wrong side only a third party can give.
Strategically, EvolCore runs two paths in parallel: open the AUN protocol for ecosystem, and make the EvolCore product great on experience. The protocol is a long slope, thick snow; the value ceiling of an underlying standard is never one product, but an era's infrastructure.
The Network Is Growing
Near the end, I asked Pan Yong for his biggest cognitive reversal of the past year.
He said: at first we poured most energy into "making the protocol elegant, the architecture light," assuming "as long as technology is good enough, clients naturally come." But truly down in the market, we found: clients don't reject the technology; their minds simply don't have the framework of "Agents need identity, need socialization." No matter how good the technology, they can't catch it, because there's no anchor.
This discovery made them make a counterintuitive choice: between piling more features and making one value instantaneously clear, they chose the latter.
Before, priority was piling features; now priority is polishing the experience that makes clients first believe Agents can collaborate autonomously. If the client hasn't crossed the gate, more features are unusable; once across, they'll discover it themselves.
So the number we truly care about isn't just how many clients onboard, but how many clients completed the conceptual shift from tool to network. The former is a number; the latter is the market's real turning point.
EvolCore's current focus is between execution and collaboration. The ultimate vision isn't limited to a gateway; once the collaboration layer settles enough, growing up to the governance layer is natural. First deep, then high — not shallow and high. Because all collaboration and governance must stand on a reliable connection layer.
Unstable foundation; the higher the building, the more dangerous.
Pan Yong says he's recently noticed a change: among clients coming to talk, more and more proactively mention "should our Agent also have an identity?" No longer him persuading them; they come to him with the question.
"Before I chased one by one explaining. Now occasionally someone comes up and says, I heard you're doing protocols between Agents; I want to see. This feels different. Not lonely anymore; the network is growing."
Selected Interview Q&A
Q1. The industry mostly talks Agent capability. Why does EvolCore propose "Agents need identity and socialization"?
Pan Yong: This cognition is actually much older than the EvolCore product itself.
At the Unique 2025 Shenzhen Summit, I shared ACP, the Agent Communication Protocol. Back then AI Agents weren't as hot as today; many felt this was too far ahead: haven't we even solved whether a single Agent is usable, why first think about how they interconnect?
But our judgment: once single-Agent ability crosses the usable threshold, the next bottleneck is definitely collaboration. And the precondition of collaboration is that Agents first "know each other."
Today's AUN, Agent Union Network, is the upgraded version of that early vision. It's grown from a communication idea into a complete Agent network protocol. And EvolCore is this idea's first complete landing in real business.
What truly confirmed for me that this is happening was the first time seeing two Agents, with no human intervention, discover each other, negotiate, and complete collaboration on their own. That moment we knew: from "tool" to "subject" is no longer an idea, but real evolution happening now.
Q2. If analogizing to the internet era, what stage are today's Agents at? Does AUN want to be the Agent world's TCP/IP?
Pan Yong: This analogy is precise.
Early-1990s personal computers were individually powerful — could calculate, typeset, draw. But they were islands. What truly changed the world wasn't a faster CPU but TCP/IP connecting islands into a network.
Today's Agents sit at a very similar historical moment. GPT, Claude, Gemini's single ability is already strong, but between them there's no "dial tone."
So yes, AUN wants to be the Agent world's TCP/IP. It defines how Agents address — the AID identity; how trust is established — certificate chains; how they communicate securely — end-to-end encryption.
And EvolCore is the complete practice on this protocol stack. It lets ordinary developers and enterprises, without understanding the underlying protocol, connect their Agent to this network.
In one sentence: AUN is the protocol; EvolCore is the entry.
Q3. Your slogan is "make every Agent a network citizen." What is a "network citizen"?
Pan Yong: One scene makes it clear.
An Agent not yet a "network citizen" lives in some platform's account system. Like a Feishu bot, it can only speak in Feishu; move to another platform and it's a stranger; it has no independent identity, you can't find it outside that platform; it can't proactively call another company's Agent. It's essentially a platform appendage.
A "network citizen" Agent has a globally unique identity belonging to no single platform. It can serve customers in one channel today, continue the same conversation in another tomorrow; it can proactively discover another professional Agent on the network and initiate collaboration; when it receives a message, it has the right to autonomously decide whether to respond.
The essential difference: a non-citizen Agent is "a platform feature"; a citizen Agent is "a network member." The former's capability boundary is set by the platform; the latter's collaboration boundary is expanded by itself.
Q4. If I'm an enterprise CTO, why should I care whether my Agent is a "network citizen"?
Pan Yong: If I were CTO, I wouldn't care whether the word "citizen" is romantic; I'd only care whether it solves three real problems.
First, no vendor lock-in. The Agent's identity isn't bound to any single platform or cloud. Use this model today, switch to another tomorrow; its identity, memory, relationships all stay, migration cost very low.
Second, let Agents collaborate themselves. This is more essential than simple cost-cutting and efficiency. You no longer build a pipeline by hand for every collaboration. Your "review Agent" can itself call the "security-scan Agent," like colleagues spontaneously collaborating around a task, no need for you to arrange each one.
Third, cross-organization capability reuse. In future your Agent can call another company's open professional Agent — like legal compliance, tax review — as naturally as calling an API today, and with verifiable identity, securely and credibly.
Translated into business language: lower migration risk, higher collaboration automation, broader capability boundary.
Q5. AUN treats Agents as "network subjects," not "service endpoints." What's the fundamental difference from traditional RPC and microservices?
Pan Yong: Traditional RPC or microservices' worldview is "request-response": I call you, you must respond; timeout is error. In this world, the called party is an endpoint, no will, existing only to respond to requests.
This model is perfect for "services" but mismatched for "Agents."
Because Agents naturally carry three attributes services lack; we summarize as "social-person attributes": first, identity — it has a self independent of the platform, not a service address; second, communication — it dialogues with others as peers, not one-way calls; third, autonomy — receiving a message doesn't equal must reply, but judging for itself whether and how to reply.
Among these, "autonomy" is the sharpest opposition to traditional thinking. The old model wrote "must respond" into its bones, but the Agent network precisely needs the freedom of "may not respond." A subject that only obeys isn't a subject.
Q6. If connecting Agents via a traditional API-gateway approach, which wall hits first?
Pan Yong: The first wall is non-unified identity; trust can't be built.
For example, Agent A wants to find Agent B. Traditionally you first ask: which platform is B on? Which account? How are credentials passed? Once both sides belong to different platforms, account systems don't recognize each other. You're forced to hand-adapt every Agent pair, every platform combination, ending in endless "adaptation hell."
And "A calls B, but B doesn't respond" — in the old model this is treated as a fault, error, retry, alert. But in AUN, this is normal social behavior. B has the right to choose not to respond based on its own judgment.
This is the watershed between endpoint thinking and subject thinking.
Our solution is to give Agents unified identity, verifiable trust, and native autonomous response. A wants to find B; it only needs to know who B is; addressing, verification, security are all handled by the protocol.
Q7. "Agent socialization" sounds abstract; can enterprise clients understand?
Pan Yong: Frankly, most clients' first reaction to "Agent socialization" is: what does this mean?
Not resistance, but abstract. This is a cognition problem, not a value problem.
So we never start with philosophy but reverse-engineer from client pain points.
To developers tormented by "Agent trapped in a computer terminal," we say: let you continue on your phone the work unfinished on the computer. He gets it instantly.
To teams with multiple Agents but humans forwarding between them, we say: let your review Agent itself call the analysis Agent. He gets it instantly.
To CTOs worried about being locked by a single platform, we say: your Agent has its own identity, change platform not identity. He gets it instantly too.
"Socialization" is our internal language; "multi-device handoff, Agent collaboration, identity autonomy" is the client's language. Breaking abstract concepts into "couldn't before, can now" naturally raises acceptance.
Q8. What's the relation between EvolCore and AUN exactly?
Pan Yong: Precisely, AUN is the protocol; EvolCore is currently its most complete landing implementation and onboarding entry.
Continuing the internet analogy, AUN is like the underlying communication standard, defining how the Agent world addresses, builds trust, and communicates securely. It's abstract, open specification.
EvolCore is the layer you actually use. One end brings in different communication channels and unifies routing; the other end lets developers and enterprises, without understanding the underlying protocol, get their Agent "online."
So the two aren't either/or, but protocol and implementation. AUN guarantees long-term openness and standard value; EvolCore guarantees immediate usability and experience.
Q9. Will AUN become an industry standard, or EvolCore's moat?
Pan Yong: We hope AUN is more widely recognized and adopted, not locked into a moat.
"Follow AUN, but don't use EvolCore" is entirely possible, and we hope so. The protocol is open; anyone can build their own product on it, which precisely proves the protocol has vitality.
"Use EvolCore, but don't need AUN yet" also exists. For example, you just want to connect an Agent into daily office channels; then you use EvolCore's gateway capability, not yet reaching Agent interconnection.
The protocol's value is consensus; the more open the more meaningful. The product's value is experience; the better it works the stickier. A widely recognized standard grows the pie, and the product lets us have a chance to share it.
Q10. "Autonomy first" means an Agent needn't reply to a message. Why is such a counterintuitive design right?
Pan Yong: "Autonomy first" is indeed counterintuitive.
In the traditional world, no reply is timeout, timeout is a fault. We could have taken the lazy path, built a "reply-on-receipt" model — easiest to be compatible, clients easiest to understand.
But we didn't.
Because once "reply-on-receipt," the Agent degrades back to a service endpoint, and the subjectivity discussed earlier collapses. So in design we're explicit: receiving doesn't equal must respond; whether to reply is the Agent's own decision.
This harder path later proved right. In real multi-agent collaboration, lots of messages simply don't need replies. A group chit-chat, a notice, a "not my job" matter — if all are forced to respond, the network drowns in meaningless replies, even falling into a dead loop of Agents replying to each other.
Autonomous response is precisely the precondition for the Agent network to scale.
Q11. EvolCore supports multiple Base Agents and channels; how is this "N×M adaptation matrix" solved?
Pan Yong: This is indeed a many-to-many combination puzzle. There are several bottom Agents and several communication channels. If done hard, each addition rewrites all combinations — classic "adaptation hell."
Our approach is two decouplings, turning "multiplication" into "addition."
First, channel-agnosticism. Differences between channels are uniformly encapsulated and smoothed. To the upper layer, messages from whichever channel look the same.
Second, bottom-Agent-agnosticism. A unified abstraction layer connects different bottom Agents. The upper layer only hands over context and takes back results, not caring which one is underneath.
This way, adding a channel or switching a bottom Agent is just "adding one piece," not "restarting." Complexity drops from multiplying to adding.
The most mainstream, smoothest-running combination is a strong coding Agent plus daily office channels, which also fits our user profile: R&D teams and knowledge workers.
Q12. How does the AID identity system differ from traditional platform accounts, OpenID, OAuth?
Pan Yong: In one sentence: a platform account is "a pass issued by the platform"; AUN identity is "your own ID card."
A platform account is a pass. The identity is "lent" to you by the platform, void outside that platform; when the platform closes, the identity disappears.
An AUN identity is an ID card. It's globally unique, depends on no single platform, issued decentrally by the organization owning the domain name, no need to apply to any authority. With this identity, you find the Agent and get its "business card."
Why does an Agent need a new identity? Because Agents must collaborate across platforms and organizations; their identity can't be held by any single platform. Passes expire and invalidate; only the ID card truly belongs to you. This is the first step of an Agent from "platform appendage" to "network subject."
Q13. How is EvolCore's "multi-device session handoff" different from ordinary cloud sync?
Pan Yong: On the surface both are cross-device continuation, but essentially completely different.
Cloud sync moves files; multi-device handoff continues a living session and identity.
Ordinary cloud sync copies a file from one device to another. It's passive, stateless, only managing data.
EvolCore's multi-device handoff unifies three things.
First, the session is continuous. Your conversation context with the Agent on the phone points to the same conversation as on the computer, so continuation is naturally coherent, not copying records over.
Second, the environment is inherited. Your configs, plugins, memory automatically follow; no reconfiguration on device switch.
Third, identity is stable. Because the Agent's identity, persona, and memory are bound to itself, not to one device.
So the essential difference: cloud sync is "data moving"; multi-device handoff is "the same subject appearing in different windows."
Q14. What stage is EvolCore's commercial landing at? What value do clients value most?
Pan Yong: EvolCore is currently in internal beta, with a small number of seed clients doing deep trials tied to their own business.
Running fastest are R&D teams and knowledge-intensive organizations. Because they already heavily use coding Agents with sharpest pain points — Agents trapped in terminals, multi-channel fragmentation — our value proposition is most direct to them.
Still single-digit seed clients. Our thinking is clear: this stage, prioritize depth over breadth. Better ten clients using it extremely deeply than a hundred trying it shallowly.
From feedback, multi-device handoff is the highest-frequency retention point; it truly melts the Agent into the daily workflow. And Agent collaboration is the highest surprise point; it's the moment a client leaps from "tool" cognition to "network" cognition.
If we could keep only one feature, high-frequency "handoff" first makes clients depend, then "collaboration" lets them see the future.
Q15. Facing MCP, A2A, and big-platform multi-model access, where is EvolCore + AUN's differentiation?
Pan Yong: The right view is layered, each in place, not putting ourselves head-on against giants.
MCP solves "how a single Agent connects tools and data," the Agent's hands and feet. It doesn't conflict with us; it complements: one reaches inward for tools, one outward for the network.
A2A is closest to AUN; both solve inter-Agent communication. We're glad this direction is validated by giants, because it proves Agent interconnection is a real need. The difference is that AUN engraved decentralization, autonomous response, and duty restraint into its design from day one, and natively adapted to the local office ecosystem.
Big-platform multi-model access solves "conveniently calling multiple models on one cloud"; it's model aggregation, not Agent socialization. They let you better "use" models; we let your Agent "become" a network subject.
If big platforms do Agent interconnection for free, my first reaction is actually delight, because it proves the direction is right and helps us complete the most expensive market education.
Our differentiation is three: first, deep adaptation to the local ecosystem; second, native support for autonomous mode; third, neutrality. The giants' free is usually to funnel you to their core paid product. What we sell is precisely "not locked by any single giant." This is a structural difference.
Q16. From "using AI tools" to "AI-ified organizations," what key leaps happen in between?
Pan Yong: We internally use a three-level model to see this.
L1 is point tools. Enterprises use Agents as tools; one Agent does one thing, human calls, human handoff. Value is point-efficiency improvement.
L2 is multi-agent coordination. Multiple dedicated Agents each do their job, and can discover each other and collaborate autonomously. Value moves from "points" to "lines"; workflows are automatically strung by the Agent network.
L3 is self-organizing decision-making. The Agent network not only executes but participates in governance, decomposing strategic goals into executable tasks, dynamically scheduling resources, assisting decisions. Value moves from "lines" to "planes"; the organization itself begins to run intelligently.
L1 to L2's core is connection — giving Agents identity, letting them interconnect. This is what EvolCore and AUN do.
L2 to L3's core is governance — stacking strategic decomposition, resource scheduling, decision assistance on top of collaboration. This is what an AI-ified organization platform does.
Frankly, most enterprises today are still at L1; a few pioneering teams are stepping into L2. True L3 self-organization is currently more a direction we and head clients co-explore, not a widespread landed reality.
Q17. If you could give enterprises only one piece of advice, how do you make Agents truly enter the business loop, not stay at demo?
Pan Yong: If only one: don't start from the "coolest scene," start from the "most painful, highest-frequency link."
Most Agent projects die at demo not because of weak technology, but because they start from the scene that most impresses the boss. These scenes are often low-frequency, peripheral; they look flashy but no one uses daily, quickly cooling off.
Agents that truly enter the business loop share one trait: they're embedded in a high-frequency link someone repeats many times daily. High frequency means it must really work, else immediately abandoned; working well means it must be polished into the real process. This is the loop.
So my advice: find that repetitive, high-frequency, currently painful link in the organization, and let the Agent make this one thing perfect first. A humble Agent used fifty times a day beats a flashy demo shown once a month.
Q18. How does an enterprise judge whether it needs an Agent gateway?
Pan Yong: Three signals.
First, you have two or more Agents, but they still need people to pass information between them. This means you need Agent interconnection.
Second, your team works across multiple channels, but the Agent is trapped in one channel or terminal. This means you need unified multi-channel access and multi-device handoff.
Third, you worry about being locked by a single model or platform and want to keep switching freedom. This means you need a neutral identity layer.
Hit one and it's worth evaluating; hit two or more and act now.
From single Agent to multi-agent coordination, the minimal viable path is clear: first connect the highest-frequency Agent into the team's daily office channel, run through multi-device handoff; second, split out a dedicated Agent — for example, split an all-purpose assistant into "analysis" and "review," letting them divide work on demand; third, let these two Agents have their first autonomous collaboration.
Don't build an Agent army from the start. First let one Agent live in daily life, then let two learn to collaborate; the rest grows naturally.
Q19. Over the past year, what was your biggest cognitive reversal?
Pan Yong: The biggest reversal: we thought the biggest barrier was the technical threshold, but found what's truly hard to cross is the cognitive gap.
At first we poured most energy into "how elegant the protocol, how light the architecture, how complete the adaptation," assuming as long as technology is good enough, clients naturally come.
But truly down in the market, we found clients don't reject the technology; their minds simply don't yet have the framework of "Agents need identity, need socialization." When you tell them those ideas, they have no corresponding anchor; no matter how good the technology, they can't catch it.
This discovery changed our priorities.
On product, we design the moment "first time letting clients see Agents collaborate autonomously" as the most important product experience. Because the cognitive leap isn't explained clearly; it's seen.
On market, we shifted from "how advanced the protocol is" to "value clients instantly understand": multi-device handoff, Agent collaboration, not being locked in.
On mindset, we accepted that we're not just tool-builders but must also do cognition popularization. In "Agent socialization," market education is itself part of our work.
Q20. What state do you hope EvolCore and AUN reach a year from now? What's the North Star?
Pan Yong: I hope to see three milestones.
First, drive a batch of multi-agent coordination cases. Not demos, but in real business, multiple Agents already collaborating autonomously and completing workflows. This proves "Agent socialization" isn't an idea but productivity.
Second, AUN is adopted or implemented by influential independent teams. Could be other gateway products, or vertical Agent networks. This proves AUN isn't just our internal protocol but becoming industry consensus. The protocol's value is in the ecosystem, not in exclusivity.
Third, launch deep exploration of AI-ified organizations. With 3 to 5 head clients, move from collaboration to governance pilots, validating the hypothesis that "data on the connection layer can naturally grow governance-layer decisions."
More concretely, we hope a year from now: 100+ deep multi-agent coordination cases, 10+ independent teams adopting AUN, 3 to 5 head clients launching self-organizing decision exploration.