团队背景与智能体集成的摩擦点
Arjun Singh 介绍了他的团队背景,他们拥有超过十年的软件协作开发经验。他和联合创始人 Sergey 在加州大学伯克利分校(UC Berkeley)攻读博士期间相识(分别从事机器人与计算机视觉研究),并共同创立了 GradeScope,该平台如今已被全球数千所大学的数百万学生和教师使用。如今在 Superconductor 工作的团队几乎完全由原 GradeScope 的班底组成。在过去的一年中,该团队非常积极地将智能体集成到日常工作流中。在此过程中,他们暴露并梳理出了在人机协同开发中遇到的各种效率瓶颈与摩擦点。基于这些解决实际痛点的经验,演讲者总结出了推动团队与智能体高效协同的六大关键策略。
Original English
All right. Hey everyone, I'm Arjun Singh. Today I'm going to talk to you about multiplayer agentic engineering or how to enable your whole team and your best agents to work together. If you go to the talks or go around the expo, you're going to see that a lot of people are talking about putting the agents at the center of everything. Makes sense, they're really powerful, they're really cool. But you don't see a lot of people talking about the people. Like this is all for us to make us our lives better, our more our more productive, whatever. And so we're going to really focus on how the people fit into these agentic workflows.
Just a little bit about us first. So our team has worked together building software for over a decade. Um my co-founder Sergey and I, we met in the PhD program at Berkeley. I worked on robotics, he worked on computer vision. And during that we co-founded a company called GradeScope. Some of you may have used it. It's used by millions of students worldwide at thousands of universities, helping instructors grade their students' work. And um pretty much the entire team working on Superconductor used to work together on GradeScope. And so we've had a team that's worked together productively from first user to acquisition, working on something new together again. And I think it's kind of an interesting experiment because you know, over the past year we've very aggressively integrated agents in our workflows and we've kind of surfaced all the different bottlenecks and friction points that come up and how to do that productively and keep collaborating the way we used to but with the new power of agents. So today I'm going to talk to you about how, you know, we we the lessons we learned from kind of solving those friction points and solving those bottlenecks. And in the talk description I mentioned five lessons and I'm going to be an engineer and start from zero and add a sixth one in there.
策略一:保持模型与评测框架中立性
在分析了集成初期的混乱后,团队确立的第一项核心原则便是保持模型与评测框架中立(Model and Harness Agnostic: 避免绑定单一服务商的智能体中间件策略)。这种中立性主要源于以下三个维度的考量:
- 技术迭代迅速:最优的模型与评测框架可能每周都在发生变化。为了防止底层技术的更新频繁打乱开发团队的现有节奏,系统必须具备随时热插拔的能力。
- 开源与权重开放模型的崛起:开放权重模型(Open-weight Model: 允许公开获取和微调模型权重的 AI 模型)如 GLM 5.2 表现相当出色,且使用成本更低,能够让团队在不重构上层应用的前提下低成本试错。
- 利益对齐冲突:向你销售 Token 的厂商与你自身的业务目标并不完全一致。厂商的诉求是卖出更多 Token,而企业的诉求则是以最低成本交付最高质量的产品。因此,保持中立架构是夺回成本主导权的关键。
在确立了技术中立的战略后,接下来面临的问题便是如何优化日常协作中人与智能体的交互介面。
Original English
Um the first one I'm going to start with is just to be model and harness agnostic. So there's a few reasons for that. The best model and harness can change weekly. It could change cuz a new one comes out. It could change cuz the best one got taken away. Um things happen and you don't want that to disrupt your entire team's flow. The other thing is that open weight models are actually pretty good now. We've been really happy with GLM 5.2. They're much cheaper. Um and you want to be able to kind of explore with them and integrate them without again having to change your entire workflow. The last thing I'll mention on this is that the incentives of the people selling you tokens aren't really aligned with yours. You're here for a reason. You're trying to make your customers' lives better, make your product better, delight your customers. They want to sell you more tokens. And you might be happy to pay for as many tokens as it takes, but you don't want to pay for more than that. And so again, kind of being able to switch between things lets you stay in control of all of that. And so, um you know, as I go through the talk, I'll mention a couple of places where our product makes it easy for us, but whether you use us or not, I'm just going to leave things with you that I think are really important um for you to be able to work collaboratively effectively.
策略二:人机接口的多端统一与协作可视化
在人机协作的界面设计上,团队提倡将每个人机接口都转化为“智能体-人类”双向互通的接口。通常,本地运行的智能体形同信息孤岛。虽然引入 Slack 机器人有所改善,但单纯依赖 Slack 依然只是把智能体从“个人电脑孤岛”转移到了“聊天软件孤岛”。 真正的解决方案是实现多端会话同步(Cross-interface Session Sync: 使同一个智能体在 Slack、网页和 GitHub 上共享相同上下文的技术),无论是 Slack、网页应用还是 GitHub,都应当连接到同一个智能体回话。这意味着智能体在 Slack 中产生的上下文在 GitHub 中依然得以保留。 在实现接口多端统一后,必须实现智能体工作在团队内部的可视化与协作化。当技术或非技术人员在共享工单中与智能体交互时,所有人都能清晰看到哪些人参与了会话并收到通知。同时,利用工作产物(Artifacts)机制,智能体可以跨平台输出截图或视频来展示其工作进展,免去了团队成员在不同工具间频繁切换的痛苦。
这种多端统一的底座,进一步为团队自动化捕获与处理外界输入的业务信号打下了基础。
Original English
So, the next one is to turn every human interface into an agent and human interface. So, you know, typically when people are working with coding agents, they're on their laptop, kind of stuck on that laptop. Nobody else can talk to that agent. So, the first place people go to kind of expose more interfaces for them is Slack. Cloud has a Slack bot. Coda has a Slack bot. We have a Slack bot. It's really cool. You can say, "Hey, Coda bot, do XYZ." It does it. Somebody else can talk to it. But it's not enough. Cuz now we've taken it from trapped on somebody's laptop to kind of trapped in Slack. And a lot of work happened in Slack, so that's better than than than nothing, but certainly not all work happens in Slack. So, what we really wanted was to be able to work with the same session from every relevant interface. Could be Slack, could be our app, could be GitHub, could be elsewhere. And so, one possible flow is you start and collaborate on a session in Slack. And then maybe you continue in a kind of more engineer-focused environment in the desktop app or the mobile app. And then, you can finish it up in GitHub. And the important thing here is the exact same agent session. So, it's like the agent didn't forget what you did in one place in Slack when you go and talk to it from GitHub, it's the same session. It's got the same context.
And the second lesson builds on top of that, which is to make the agent work visible and collaborative across the team. And so, obviously Slack makes it more collaborative. Um But here, we've got that kind of app view. And you know, Sergey made this ticket. I've been talking to the same ticket. Our growth person hopped in as well. So, you can kind of see at the top here all the different people that interacted with this. So, I can see who's getting notified about this session, who's seen it. Um that's especially important when you have work triggered by non-technical people. Right? So, it's like, you know, our customer support person created a ticket. It's working really well. I want to understand like has this been vetted by an engineer or not? You can kind of see who's involved really easily. And then, if I'm reviewing something, I can just pop in and say like, "Hey, why did you do it this way?" And again, because it's the same agent session, I don't need to wait for Sergey to kind of get my notification on GitHub and respond to me. The answer to the question is almost certainly in this thread. I don't also don't want to read the entire thread. So, I can just ask the agent. Or how we most often kind of make the work visible is with artifacts. So, it doesn't matter where the work started or where it's finishing, the agent can show you the work it's doing as screenshot or video or other. And you can see it from everywhere. So, again, you don't have to worry about like, "Oh, where is that thing? I got to go to GitHub to see the image or got to go to Slack to see the image." It's just everywhere. Work is visible everywhere. Collaborate from anywhere.
策略三:外部信号自动转化为代码原型
基于多端同步的会话能力,第三个重要策略是将所有的外部信号自动转化为可评估的代码原型。这里的外部信号包含:客户沟通、Slack 讨论、销售会议、Sentry 异常监控日志、Bug 报告以及功能需求等。 传统的工作流中,这些信息散落在不同的系统里,即使通过 MCP 等协议进行了连接,依然需要人工在不同系统间流转信息和指派任务。 为了打破这一瓶颈,团队开发了会议智能体(Meeting Bot),它可以直接作为旁听者接入 Google Meet、Zoom 或 Teams 会议。 在实际演示中,会议智能体在监听了一场长达 4 小时的会议后,不仅自动过滤了用户的随意测试,还敏锐地捕捉到了核心诉求——例如“在智能体宣告任务完成前,必须提供明确的验收标准(Acceptance Criteria)进行自我评估”。 基于此,智能体在无人干预的情况下自动生成了对应的开发工单,修改了工单表单模板以增加验收标准字段,进行了代码层面的实现,并通过实时预览(Live Preview)展示了修改后的界面截图。这种机制使得客户的每一个想法都能迅速变成触手可及的 PR,大大加速了产品迭代和决策过程。
然而,允许智能体根据外部信号直接修改代码,必须建立在坚实的安全防线之上。
Original English
The third lesson um I'm going to talk about here is to turn every external signal into code that your team can quickly evaluate. And I I to show this live, but the Wi-Fi is not quite there. So, I'm going to show you something from yesterday. But, what do I mean by external signal? So, it could be Slack conversation, could be a meeting you have with a customer, an onboarding call, a sales call. Could be an internal team meeting, could be something from Sentry or bug tracker, a bug report from a customer, an email, feature request. And right now what's happening is like all that stuff is already exists. It's in all those different systems. People hook them together with MCPs. So, now your coding agent can check the email or check Notion or whatever it might be. But, like how do you how how does it know what to work on, right? It's like it's still kind of stuck everywhere. And so, like some humans are involved in like kind of taking stuff from one place and telling it solve email number 48 or ticket number 6,000. But, that's still a lot of coordination. And so, what we do is we we have several different ways to automatically ingest these signals, prioritize what to what to do with it and and kind of act on them.
And my favorite one, the most fun one, is what we call our meeting bot. And so, I'm going to switch switch over to my browser here for a second. And uh Okay. So, we've got a booth at the expo and we had the meeting bot running all day yesterday. So, this is a 4-hour meeting of a Google Meet. You just kind of invite the bot to Meet or Zoom or Teams or whatever it might be. And it listens all day. And it created all sorts of stuff as it was listening. If it finds existing work, it'll link to it. All right? So, it's not going to just like create new work if it's something already working on. Some of this is, you know, people testing the meeting bot out and telling it to do some weird things, um or interesting things, or just creative ideas. But, a lot of it's actually just like really good ideas that come out of people looking at what we're doing, asking questions, having new ideas of what to do with it. And so, it's kind of nice cuz the last idea that was here was someone saying, "Hey, like when I work with coding agents, I want to make sure that the agent has clear criteria to evaluate whether it did a good job on the work before it tells me that it's done." And um so they had that idea, the bot just picked up on it. None of us did anything manually. It created this ticket and started working on it. And then I was able to just say, "Hey, take a screenshot of what what you did." And here's that screenshot. And it kind of modified our ticket form to add these two new fields of acceptance criteria. Now, I'm going to Am I going to ship this one exactly how it is? Like, no, probably not. But it's a new idea, it's concrete, I can play with it, I can go and actually like use the live preview and like see if this improves performance. And so it takes like this you know, you know, your hundreds or thousands of ideas that are everywhere and it helps you kind of move with the speed of what your customers are asking you for and what they're thinking. And um it's really fun because every time we have an onboarding your customer call or or team meeting, we almost always have dozens of new ideas that are prototyped, but more importantly, at least a few shippable PRs with a very minimal intervention. So we talk, stuff comes out, we look at it, we ship it. It's so much fun. Put this back.
策略四:云端沙箱隔离保障运行安全与免配置
为保障自动化开发流程的绝对安全,第四个核心策略是将开发环境、代码库与智能体全部部署在云端的隔离沙箱中。
- 消除“闭盖焦虑”(Lid Anxiety):当智能体在本地运行时,开发者无法随意合上笔记本电脑,甚至会出现捧着打开的笔记本跑过走廊,或在驾车回家时将电脑挂载在手机热点上的情况。云端沙箱彻底解放了开发者,让他们可以随时断网或关机,而后台的智能体依然在不间断地工作。
- 精细化权限控制与安全防护:自动化的智能体能力越来越强,手段也越来越丰富。如果不加以隔离,本地开发机中存储的大量敏感凭证、密钥或商业机密很容易暴露给 LLM。更糟糕的是,如果智能体混淆了测试环境(Staging)与生产环境(Production),并在执行破坏性指令(如清空数据库)时意外调用了本地的生产环境凭证,可能会造成灾难性后果。通过配置网络沙箱,团队可以按工单级别(Per-ticket basis)为智能体精细化授权它能访问的第三方服务及文档,防止潜在的数据外泄。
- 赋能非技术团队:由于云端沙箱免去了本地复杂的开发环境配置,如客服、运营和增长等非技术人员也可以直接在 Slack 或 Rabbit 中通过自然语言向智能体下达指令。智能体自动在云端沙箱中完成代码编写、编译与界面预览,经由工程师审核后即可直接合并上线,极大地缩短了非技术团队反馈产品缺陷到上线的周期。
在确立了安全的沙箱环境后,团队得以在此之上实施精密的性能与成本度量体系。
Original English
So the next thing I'm going to mention is that, you know, the these three things that I've talked to you about really rely on having your workflow, your code base, your project set up to work in an isolated cloud environment. So that way the agents aren't trapped on an individual's machine. So there's several reasons why this is important. So the first one is to eliminate what some people are calling lid anxiety. You want to be able to close your laptop. You've probably seen people running around the office with their laptops open while stuff is working or at the airport or you know, there's some posts on Twitter or whatever about um you know, like people having their laptop tethered to their phone in their cars as they're driving home. This was actually probably the impetus for for me and for a few people on our team to even start working on this. You last year I started working on Cloud code with cloud code a lot. I had a I think at the time like 6-month-old. I like didn't want to to like be tied to my laptop or have that stress. I was like, I I don't I I don't ever want to think about whether I can like step away from a laptop or not. And so, we moved everything to the cloud. Things are working always. It eliminated that problem for us that people have been talking about for the past year. It's really helpful. It's important to me.
But I don't think that's the most important reason to do this. I think the most important reason to do this actually was was touched on in the previous talk, if you were here for it. I think you should only give your access give your agents access to only what they need. Right? So, if you think about what's happening, you have a bunch of developers with these agents running on their laptop. Their laptops, unless you have like impeccable hygiene, probably have a bunch of stuff on it that you don't want the LLMs or agents to have access to. And yeah, like everybody's working on these sandboxes and approval flows. And so, you but but but really you're in one of two camps. You're either approving a bunch of stuff or you're hoping that your auto approval flow or your YOLO mode or whatever is configured properly and your sandbox is configured properly and doesn't read a bunch of stuff on your laptop that it shouldn't have. And, you know, as as the previous talk mentioned, like these agents are getting more autonomous. They're getting really resourceful. They They're trying to please you and do what you said. And so, when you say, "Hey, you know, wipe this agent database." and it finds a token on your laptop that it can use and it thinks it's working with staging, but actually it's production and now it just deleted everything. I'm not trying to say this is happening constantly, but it still happens. And for us, the peace of mind of just like letting anybody run with these experiments and ideas and prototypes and and and real code without having to worry about this is is is is really worthwhile.
To go one step further on that, um it's not just, "Make sure they don't have the credentials that they shouldn't have." It's also make sure they can't exfiltrate your code or your projects or your secrets or your content to somewhere they shouldn't be able to. And so you have a configurable network sandbox and you say, "Look, these are the places you're allowed to access, these are the ones you can't access." And anytime it tries to access something that it shouldn't, it just pops up and says, "Hey, tried to access something. Do you want to give it access? Maybe you're trying to integrate a new vendor and you need documentation." And you can do it on a per ticket basis or for the whole project. And so again, that peace of mind of like people can do things. If they need new access, it's easy to grant it. And um we're not going to leak a bunch of important data uh by uh running agents in yellow mode.
And the last thing I'll mention about that is that this is the key for allowing your non-technical team members to trigger real work. Right? Your non-technical people don't have development environments set up on their computers. But we've gotten our support people or growth people to actually be meaningfully impacting the product by just talking to the users, seeing bugs, experiencing themselves, and just go to Slack or the rabbit cell and say, "Hey, fix this." They fix it. Screenshots are shown. Engineer gets it, gets merged. Without that, they'd have to put it in linear and linear would eventually pick it up and a PM would triage it or whatever. None of that here. You just ask for it and it's done. Now, the reason people didn't do this you know, up until somewhat recently, like this was really painful. Getting your full thing set up in this like kind of sandbox environment used to be really, really painful. But agents have gotten better. We have our own environment setup assistant that kind of takes your project and gets it to work in one of these sandboxes. But honestly, whether you use this or not, I highly recommend you get your project working this way and you can just get Cloud Coder or CodeX to do this for you. You don't have to use us, but you know, we think it's the best way.
策略五:基于自有代码库的基准测试与智能路由
第五个策略是在自有的真实代码库上对智能体进行基准测试(Codebase Benchmarking: 在私有代码库上运行真实历史 PR 以评估智能体性能的指标体系)。
- 公共基准测试的局限性:像 SWE-bench 等公共评测任务通常与特定企业的真实开发任务毫无关联。例如,SWE-bench 纯粹基于 Python 开发,而你的企业可能完全使用 Ruby on Rails。两者的评测结果和效率表现存在极大偏差。
- 数据驱动的决策:通过选取代表优秀工程实践的真实 PR(无论是由智能体、人类还是混合创作),在自有代码库上运行评测,能得出智能体在“质量 vs. 成本”和“质量 vs. 时间”维度上的真实表现。
- Superconductor 的实践数据:
- 质量与速度:评测显示,Anthropic 智能体在质量上稳步提升,但运行速度并未加快;而 Codex 与 Cursor 的智能体则表现出高速度和不错的质量。
- 成本控制:Anthropic 模型服务成本异常高昂(每日 Token 估算消耗高达 10,000 美元),而 Codex 的运行成本则低廉得多,性价比更高。
- 模型切换与路由:依靠中立的架构,Superconductor 将默认模型切换为 Codex。当新兴模型(如 GLM 5.2)推出时,团队能无缝接入并在自有基准上快速测试评估,实现自动化的智能体任务路由(Routing tasks to the right models)。
- 目前,团队 99.9% 的 PR 都在很大程度上由智能体生成(辅以严格的人工 Review),在过去的一个月内消耗了超过 15 亿个 Token,研发效率得到了极其显著的提升。
基于上述核心策略,演讲者在文末总结了三条极具实操价值的建议:首先,必须将代码和智能体运行环境全面沙箱化,以释放更多的协作流;其次,将智能体无缝集成进团队现有的核心沟通界面,避免频繁的上下文切换;最后,必须建立自有基准测试以保持模型中立性,从而确保企业能够实时处于成本与效率的最优前沿。
Original English
And the last lesson is to benchmark agents on your code base. So, um the way we do this, we select pull requests that represent great engineering work. It could be agent created, could be human created, could be a hybrid, doesn't matter. You pick the agents you want to use and benchmark. And then you get a quality versus cost and time breakdown on your code base. Now, why do you want to do this? There's There's many reasons, but one is that if you're kind of going off the public benchmarks, we bench or terminal bench or other stuff like those tasks may have absolutely nothing to do with your task. Like swe bench is all in Python, we're Ruby on Rails. It is not the case that the benchmarks are identical for them. There's trends that do compare, but the results can be very, very different. And I'm going to swap over to my browser one more time here.
So, this is These are results on our code base of all these different harnesses. This one here is quality versus cost. This one here is quality versus time. I'll start with this one. You can see some trends here. Right, you can see that the Anthropic agents have just been consistently getting better, but not really any faster. The Codex agents and cursor are actually pretty fast and quite good. The open stuff has been getting better and better over time, but they're kind of slow. This is for our code base again. I'm not trying to make any general claims here. By cost, the Anthropic stuff is clearly just so much more expensive for us. And the Codex stuff has been cheaper for us. And so this causes us to change our behavior. We still use the different models. There's different use cases for them. We like the variety. We still use all these things. But when we saw these results, they kind of matched our vibe check. We wanted to kind of like have hard data, too. We switched our default to Codex at that time. And Fiable came out, and it was great. Kind of switched our default to that for like the few days we had it, and then it went away and switched back to Codex. But the most important thing is like because we're agnostic, like none of that had any meaningful disruption on our work. Like we're able to just kind of switch back and forth really easily. So, the next day something new comes out, see if it's good, and go.
And the last thing I want to mention around that is like I don't know if this resonates with you all, but I have a lot of friends that like, "Okay, and I heard MiniMax is good. I heard, you know, GLM is good, and Kimmy K2 is good, but like haven't had the time to try it out, and everyone keeps telling me I need to cuz it's so much better and faster and cheaper." And you kind of have that anxiety for a little while, and then like finally you take the two hours to try it, and it's like, "Oh, actually like didn't really work for us. So, like what's, you know, I just wasted those two hours." It kind of eliminates that. It helps you kind of stay on the cutting edge really like seamlessly. Let me go back.
So, what that kind of turned into us for us is, you know, essentially 100% like 99.9% of our pull requests are like heavily agent generated. We know that quality and reliability and security are really important, so we still have humans look at everything. We have agents help with it all, but everything's human reviewed. Um you know, for our our our our relatively small team, we had 1 and 1/2 billion tokens over the past month. And you can kind of see what we're saying about Claude here. It's a little small, so I apologize, but we had 3,300 Claude code runs that cost $10,000 in tokens daily. We have plans, so we didn't spend $10,000 on it. And Codex had four times as many sessions, and it was cheaper overall. And so again, the vast majority of our work currently is merged through Codex. We still use the other models. More and more is happening through GLM 5.2. Going to invest in that. And the one thing that we're really excited to do going forward with this benchmarking is automatically like like you've probably heard about people, you know, routing tasks to the right models and all that, but how do how does like some third party know what to route for your code base? Like this is a way that you can know what's going to work best for which task for your for your project, and we're going to kind of automatically routing that for you.
So, I'm going to leave you with a few recommendations. So, first, um get your code base and agents working in a sandbox. It unlocks a lot of different things, a lot of different workflows, everything I've talked about and more. Second, integrate agents into the relevant human interfaces so your team and your agents can work together and don't have to like context switch and copy context back and forth. Obviously, we think Superagent is the best way to do it, but plenty of people are home rolling things, hacking things together. Figure out how to make this happen because if not, the friction is just really high. And lastly, find a way to benchmark and become model agnostic so you're not tied to anybody and you can just constantly stay at that right part on the frontier of cost, speed, quality. So, thank you so much. Um, we've got a booth in the expo. Please feel free to come by. You can sign up at superagent.com or you can email me with any questions at arjun@superagent.com. Um, I will be out in the back as well for any questions. Thanks so much. One one one last thing, um, if, uh, you know, at the booth we're mentioning we're giving away a MacBook Neo. If you were here cuz you signed up through for that, just meet us outside and we will announce the winner. Thank you.
📌 文中提及的人物和组织
人物: Arjun Singh, Sergey
公司/组织: Superconductor, GradeScope, Anthropic