# Multiplayer agentic engineering: enabling your whole team and your best agents to work together

Arjun Singh

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/OL7kfezynJM-multiplayer-agentic-engineering-enabling) · [Video](https://www.youtube.com/watch?v=OL7kfezynJM)

## Multiplayer agentic engineering: enabling your whole team and your best agents to work together

Shared sessions, visible artifacts, isolated execution, and codebase-specific benchmarks let a whole team work with coding agents without making one developer the coordination bottleneck.

Familiarity with coding agents, pull requests, and development environments will help you follow the workflow examples.

### Where do the people fit?

[0:15](https://www.youtube.com/watch?v=OL7kfezynJM&t=15s)

What happens to collaboration when agents become the center of software development? More capable agents should make people more productive, but that requires designing how people participate in their work. Arjun Singh opens with this question: how can a team retain its ability to work together while introducing agents into its everyday workflows?

The experiment began with an established team. Singh and his cofounder Sergey met in Berkeley’s PhD program, researching robotics and computer vision respectively, and cofounded [Gradescope](https://cdss.berkeley.edu/news/john-denero-and-arjun-singh-recognized-uc-berkeley-achievement-awards). Singh describes its cumulative reach as millions of students at thousands of universities. Most of the [Superconductor](https://www.superconductor.com/) team had already worked together from Gradescope’s first user through acquisition. A year of aggressively integrating agents into that team’s workflows exposed a new set of bottlenecks: keeping context accessible, making work reviewable, and letting more people initiate useful changes.

### Keep models and harnesses interchangeable

[1:38](https://www.youtube.com/watch?v=OL7kfezynJM&t=98s)

The first dependency to remove is the connection between the team’s workflow and any particular model or **agent harness**—the software that runs the model, supplies tools, and manages its work. The best combination can change weekly, either because something better appears or because a preferred option becomes unavailable. Switching that combination should not require rebuilding how the team collaborates.

Interchangeability also makes cheaper alternatives practical to explore. Singh reports that his team has been happy with **GLM-5.2** and wants to integrate open-weight models without changing its entire workflow. His economic argument is that a product team wants better outcomes for customers, while a token vendor benefits from selling more tokens. Paying for useful work is reasonable; dependence on one vendor makes it harder to control how much that work costs. These principles apply whether the shared workspace is Superconductor or something a team builds itself.

![Slide with three reasons for model and harness independence, alongside an announcement screenshot and a post about vendor pricing.](https://ai.engineer/api/talk-essay-media/9ad720435b265f1a6a9df3a8bc7d888f23f91316d18eb2c42f2cd37348f4211c)

Lesson 0: Be model and harness agnostic.

### Carry one session from Slack to GitHub

[2:58](https://www.youtube.com/watch?v=OL7kfezynJM&t=178s)

A coding agent running on one developer’s laptop has a collaboration problem: nobody else can talk to it. A Slack bot improves that situation. Someone can ask `@Superconductor` to do a task, and a colleague can join the conversation. But moving the agent into Slack only solves part of the problem, because work also happens elsewhere.

The useful progression is to start a session with colleagues in Slack, continue in an engineering-focused desktop or mobile app, and finish in GitHub. **All three interfaces must address the same agent session.** The GitHub interaction should retain what the team already discussed in Slack; otherwise every interface change becomes another context handoff.

In Ruby, a minimal representation of that distinction is a session record whose identity remains fixed while messages arrive from different interfaces:

```ruby
sessions = {
  "session-42" => { messages: [] }
}

append_message = lambda do |session_id, interface, text|
  sessions.fetch(session_id).fetch(:messages) << {
    interface: interface,
    text: text
  }
end

append_message.call("session-42", "slack", "Add acceptance criteria to tickets.")
append_message.call("session-42", "app", "Show the proposed form change.")
append_message.call("session-42", "github", "Explain the implementation choice.")

context = sessions.fetch("session-42").fetch(:messages)
puts context.map { |message| "#{message[:interface]}: #{message[:text]}" }
```

This small representation makes the context boundary explicit: the interface is a property of each message, not the owner of a separate conversation.

### Make participation and work visible

[4:10](https://www.youtube.com/watch?v=OL7kfezynJM&t=250s)

Once a session is shared, collaborators need to understand who is involved. Singh shows a ticket created by Sergey that he and a growth colleague have also joined. Participant indicators expose who has interacted with the session, who receives notifications, and who has seen it. For work initiated by customer support, that visibility helps an engineer determine whether another engineer has already been involved in vetting the change.

Shared context also changes review. A reviewer can ask the original agent why it implemented something a particular way, without waiting for the colleague who started the work to answer a GitHub notification. The relevant discussion is already in the session. Asking the agent avoids having to read the entire thread just to recover one decision.

**Artifacts make the result accessible without requiring everyone to inspect the conversation.** Screenshots, videos, and other outputs should follow the session across interfaces. The demonstrated slide places the same interface image inside Slack and the app: a collaborator can inspect the work where they already are, rather than remember which system contains its evidence.

![Two screenshots labeled “Agent Artifact in Slack” and “Agent Artifact in App” show the same interface image within conversations.](https://ai.engineer/api/talk-essay-media/800b40ffd11ef0039ff4037c6dad66c7d89cb2e19e91fc0e59385618cd3536f8)

Agent artifacts visible in Slack and in the app.

### Access to information is not a work queue

[5:35](https://www.youtube.com/watch?v=OL7kfezynJM&t=335s)

The next bottleneck lies before implementation. Useful signals already arrive through Slack conversations, customer onboarding and sales calls, internal meetings, Sentry, bug reports, email, and feature requests. Connecting those systems through MCP lets a coding agent read their contents, but does not by itself tell the agent which work to undertake.

If a person still has to find an email, identify its significance, and tell the agent to solve that particular request, much of the coordination remains manual. Superconductor’s approach is to ingest signals, prioritize what to do with them, and initiate work automatically. The meeting bot provides the concrete demonstration. Conference Wi-Fi prevented a live run, so Singh opens results from the previous day instead.

### From a spoken suggestion to a form prototype

[6:50](https://www.youtube.com/watch?v=OL7kfezynJM&t=410s)

At the expo booth, the team left its meeting bot listening to a four-hour Google Meet. The bot can be invited into Meet, Zoom, or Teams and produce work as it listens. It also links a discussion to existing work when it finds a match, rather than creating another ticket for something already underway. The booth conversation mixed deliberate experiments with useful ideas from people trying the product.

One visitor wanted coding agents to have clear criteria for evaluating their work before declaring it complete. The resulting sequence shows the transition from conversation to something a team can evaluate:

1. The bot picked up the suggestion and created a ticket without a person manually initiating it.
2. An agent began implementation and added two acceptance-criteria fields to the ticket form.
3. Singh asked for a screenshot of the change.
4. The screenshot and live preview made the proposed interface available for inspection and use.

Singh would probably not ship that version unchanged. Its value was that an idea had become a concrete prototype he could try, including checking whether the added criteria actually improved agent performance.

The intended acceleration is from scattered ideas to evaluable work, not from conversation directly to an unreviewed release. Singh reports that most onboarding calls, customer calls, or team meetings yield dozens of prototypes and at least a few shippable PRs with minimal intervention. People still inspect the outputs and choose what to ship.

### Let execution outlive the laptop

[8:45](https://www.youtube.com/watch?v=OL7kfezynJM&t=525s)

Shared interfaces, visible work, and automatic signal processing depend on the project being able to run somewhere other than an individual developer’s machine. The codebase and its development workflow need to operate in an **isolated cloud environment**, where an agent can continue working regardless of who is currently connected.

The immediate benefit is freedom to close the laptop. Singh describes seeing people keep machines open at conferences and airports, or tether them to phones while traveling, because an agent is still running. When he began using Claude Code heavily, he did not want stepping away from his computer to become a source of stress. Moving execution into the cloud removed that dependency for his team. Convenience matters, but he considers control over access the more important reason.

### Constrain both credentials and destinations

[10:12](https://www.youtube.com/watch?v=OL7kfezynJM&t=612s)

**Give agents only the access their task needs.** A developer’s laptop may contain credentials and sensitive files unrelated to the current project. Local approval flows either repeatedly interrupt the user or depend on correctly configured automatic approvals and sandbox boundaries. As agents become more autonomous and resourceful, accidental access becomes more consequential.

Singh illustrates the risk with an agent asked to wipe a staging database. It discovers a token on the laptop, assumes the token addresses staging, and instead deletes production data. This is a risk example, not an account of an incident at his team. The point is to prevent a task from acquiring unintended authority merely because a usable credential happens to be nearby.

Credential isolation is only one boundary. A configurable **network sandbox** restricts where the agent can send code, content, or secrets. If it attempts to reach a blocked destination, it requests permission—for example, to read documentation for a newly integrated vendor. Access can then be granted for one ticket or for the project.

| Boundary | What it controls |
| --- | --- |
| Credentials and files | Which resources the agent can use or read |
| Network destinations | Where the agent can connect or send data |
| Grant scope | Whether new access applies to one ticket or the project |

These controls explain the security rationale for isolated execution; placing a process in the cloud alone does not guarantee protection against leaks.

### Let support and growth initiate real changes

[12:13](https://www.youtube.com/watch?v=OL7kfezynJM&t=733s)

Cloud execution also removes the requirement that every contributor maintain a development environment. Support and growth colleagues can encounter a bug, ask for a fix in Slack or the app, and receive a proposed implementation with screenshots. An engineer then reviews the work and merges it. That compresses the handoff through a tracker, PM triage, and eventual engineering pickup while retaining an engineering decision before merge.

Getting an entire project running inside a sandbox used to be a substantial obstacle. Singh argues that improved coding agents now make that setup more tractable. Superconductor offers an environment setup assistant, shown alongside a suggested environment configuration, but he also recommends using Claude Code or Codex to prepare the project. The essential capability is a working isolated environment, independent of which product establishes it.

![Slide recommending cloud development environments, with an Environment Setup Assistant conversation beside a Suggested Environment configuration panel.](https://ai.engineer/api/talk-essay-media/9a2f9da06c5e155f8def503981d768b4ee30dfc9bdae8fb71d6d986fa9216e33)

An environment setup assistant for cloud development.

### Choose agents using your own codebase

[13:25](https://www.youtube.com/watch?v=OL7kfezynJM&t=805s)

Once models and harnesses are interchangeable, the team needs evidence for choosing among them. Singh’s evaluation starts with pull requests that represent strong engineering work, regardless of whether a human, an agent, or both authored them:

1. Select representative, high-quality PRs from the project.
2. Choose the agents and harnesses to benchmark.
3. Compare their quality against cost and completion time on that codebase.

Public results from [SWE-bench](https://arxiv.org/abs/2310.06770) or Terminal-Bench may not reflect the team’s tasks. Singh’s concrete mismatch is language and framework: the original SWE-bench uses Python repositories, while his team works in Ruby on Rails. Trends can transfer without preserving the same ranking.

The demonstrated dashboard separates quality versus cost from quality versus time. Singh describes the following results specifically for his team’s codebase:

| Agent group | Reported local result |
| --- | --- |
| Anthropic agents | Improving quality, little speed improvement, higher cost |
| Codex | Fast, capable, and cheaper for the team |
| Cursor | Fast and capable |
| Open alternatives | Improving, but relatively slow |

These are directional observations from this project, not a general model ranking or a reproducible benchmark specification.

The results supported a change in defaults while leaving multiple agents available for different uses. The team switched to Codex, briefly preferred **[Claude Fable](https://www.anthropic.com/claude/fable)** while it had access, then returned to Codex when that access disappeared. That disappearance is historical: Anthropic subsequently announced restored access in July 2026. Because the workflow was independent of the model and harness, the team could switch without materially disrupting its work.

Local evaluation also reduces the pressure to manually try every newly recommended alternative. Singh describes friends hearing enthusiasm for MiniMax, GLM, or **Kimi K2**, postponing a trial, and finally spending time on a model that does not work well for their project. A repeatable benchmark turns that recurring distraction into a project-specific selection process.

### High agent usage still includes human review

[15:57](https://www.youtube.com/watch?v=OL7kfezynJM&t=957s)

Singh estimates that approximately 99.9% of the team’s pull requests are heavily agent-generated. Every change still receives human review, with agents assisting, because quality, reliability, and security remain engineering responsibilities.

For the previous month, Singh reports 10.5 billion tokens used by the relatively small team. He reports 3,300 Claude Code runs representing $10,000 in token-billing equivalent, not $10,000 in actual expenditure because the team used subscription plans. Codex had roughly four times as many sessions and was cheaper overall in that reported comparison. These are the team’s usage figures, rather than a controlled comparison of identical tasks.

Most merged work was going through Codex, with growing use of GLM-5.2. The next intended step was automatic task routing based on the project’s benchmark results. The reasoning follows from the earlier evaluation: a third party cannot assume which model best handles a particular codebase, but local results can inform which agent should receive which kind of task. Singh presents that routing as work in progress, not an already demonstrated capability.

### Build the execution foundation first

[17:13](https://www.youtube.com/watch?v=OL7kfezynJM&t=1033s)

The practical adoption sequence begins underneath the user interface: get the codebase and agents working in a sandbox. Then connect that execution environment to the places where the team already collaborates, so people can participate without copying context between systems. Those integrations can be built in-house; the important requirement is that they remove the friction of working with the same agent from different places. Finally, make benchmarking and model independence part of the workflow, so changes in cost, speed, quality, or availability can change the agent selection without forcing the team to change how it works together.

![Recommendations slide listing sandbox execution, integration into human interfaces, and benchmarking with model independence.](https://ai.engineer/api/talk-essay-media/70a596a99ebb263276a87a0817fdd35c915204df3aa84fe2c1cfa7271785f8cd)

Start with a sandbox, integrate agents into human interfaces, then benchmark and become model agnostic.

## Resources

- [Superconductor](https://www.superconductor.com/) — Shared workspace for teams to run coding agents, inspect previews and artifacts, and collaborate across Slack, GitHub, and apps.
- [Superconductor documentation](https://www.superconductor.com/docs/) — Guides to shared workspaces, cloud development environments, integrations, previews, and review workflows.
- [SWE-bench: Can Language Models Resolve Real-World GitHub Issues?](https://arxiv.org/abs/2310.06770) — Original benchmark paper describing repository-level issue resolution across 12 Python projects.
- [Claude Fable availability and announcements](https://www.anthropic.com/claude/fable) — Anthropic's product page records Fable's June 2026 launch and interruption, followed by restored access in July.

## Slides

### Multiplayer Agentic Engineering

The talk focuses on how people fit into agentic workflows, alongside their teams’ best agents.

[0:31](https://www.youtube.com/watch?v=OL7kfezynJM&t=31s) [Title slide for a talk on teams and agents working together.](https://assets.ai.engineer/sites/aiecode2025/sha256/8fdc2f547ee6c3153661b4524e90df52b21ce7c15a95084d1e0e0b93a3fc4e4f.webp)

Multiplayer Agentic Engineering
Enabling your whole team and your best agents to work together

AI Engineer World’s Fair
July 2, 2026

Superconductor

### About Us

The co-founders met at Berkeley and built Gradescope together. Most of the Superconductor team also worked on Gradescope, giving them years of experience collaborating before adding agents to their workflows.

[0:40](https://www.youtube.com/watch?v=OL7kfezynJM&t=40s) [Team portraits, a robotics image, and Berkeley and Gradescope logos.](https://assets.ai.engineer/sites/aiecode2025/sha256/5567f77b587d199c5336651ec6f0d0ff30c4cf01cb1953f92b295dddf11453e9.webp)

About Us

Team
Arjun Singh
Cofounder, CEO
Sergey Karayev
Cofounder
Kevin [illegible]
Cofounder
Karen Ling
Software Engineer
Ibrahim Awad
Software Engineer
Olga Stadie
Software Engineer
Galileo Friedman
Research Engineer
Surya Rajendran
Software Engineer
We’re hiring →
Join the team
[illegible]

PR2

Berkeley
UNIVERSITY OF CALIFORNIA

gradescope
AI
GROUP 1
[illegible]
GROUP 2
[illegible]
UNGROUPED
[illegible]

gradescope

Superconductor

### Lesson 0: Be model and harness agnostic

The speaker adds a sixth lesson to the five promised in the talk description, starting at zero with model and harness agnosticism.

[1:36](https://www.youtube.com/watch?v=OL7kfezynJM&t=96s) [Lesson 0 title: Be model and harness agnostic.](https://assets.ai.engineer/sites/aiecode2025/sha256/f56e668cd4630dccb78144965370ab5f722e9d39ca151cf89b25fca648fc8514.webp)

Lesson 0: Be model and harness agnostic

### Why be model and harness agnostic

Switching models and harnesses lets teams adapt as options change, try cheaper open-weight models, and control token costs. A post projects an Anthropic bill rising from $400K to $1.4M a year after crossing 150 seats.

[1:48](https://www.youtube.com/watch?v=OL7kfezynJM&t=108s) [Three reasons to remain model and harness agnostic, illustrated by an announcement and a public post about vendor billing.](https://assets.ai.engineer/sites/aiecode2025/sha256/2aa9430ce78334e2b7b1769eb4323e1f4b8e5e8e1256444cacb3a204b875840a.webp)

Lesson 0: Be model and harness agnostic

• The best model/harness can change weekly
• Open-weight models are good now
• Token vendor incentives aren’t aligned with yours

Announcements
Statement on the US government directive to suspend access to Fable 5 and Mythos 5

Marty Kausas
@marty_kausas

Our Anthropic bill is about to jump from $400K → $1.4M/yr.

Not because usage exploded, but because we're about to cross 150 seats.

Past 150 seats you're forced into Enterprise tier. Seats stop including any usage, every token bills at standard API rates. At our current run rate that's 3.5x overnight.

### Model and harness choices

A model picker offers Codex, Claude Code, and Pi options. Switching between models and harnesses helps teams stay in control as the best choice changes and token vendor incentives diverge from theirs.

[2:41](https://www.youtube.com/watch?v=OL7kfezynJM&t=161s) [Reasons for model and harness flexibility alongside an announcement and a menu of model options.](https://assets.ai.engineer/sites/aiecode2025/sha256/97845a848c7057b3318bf894c43098b73eedfb4bd1bf33075db0dd84688d0216.webp)

Lesson 0: Be model and harness agnostic

• The best model/harness can change weekly
• Open-weight models are good now
• Token vendor incentives aren’t aligned with yours

Announcements
Statement on the US government directive to suspend access to Fable 5 and Mythos 5

Codex
GPT-5.5 (High)
GPT-5.5 (Xhigh)

Claude Code
Opus 4.8
Fable 5
Sonnet 5

Pi
DeepSeek V4 Pro
GLM 5.2
MiniMax M3

### Lesson 1: Turn every human interface into an agent/human interface

Coding agents often stay on one person’s laptop, where nobody else can talk to them. The lesson is to make agents accessible through more interfaces.

[2:55](https://www.youtube.com/watch?v=OL7kfezynJM&t=175s) [Lesson 1 title: Turn every human interface into an agent/human interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/092a3e350515cfe4eafcfb0c65c286846698b5c31dfa0c003c36ea5a79903dbf.webp)

Lesson 1: Turn every human interface into an agent/human interface

### Slack bots are not enough

Teammates can ask coding agents in Slack to update timeout presets or add model support. The speaker argues that a Slack bot still confines collaboration to one interface.

[3:11](https://www.youtube.com/watch?v=OL7kfezynJM&t=191s) [Examples of coding agents in Slack accompany the statement that a Slack bot is not enough.](https://assets.ai.engineer/sites/aiecode2025/sha256/10305bc733c0cbec53af03ce57d5753960111a34901a0e478f25bc790710b185.webp)

Lesson 1: Turn every human interface into an agent/human interface

Claude:
Heads up for this channel — scheduled exports landed this afternoon in #product-eng-launches (#4131 merged). It’s now in the beta. Launch date doesn’t move. But the blog draft and the beta invite email don’t mention it. Want me to add it to both?

Han Lu:
Most of the timeouts are managed by strawberry, such as the one you are looking at for the train loop. Please add [illegible] to the command.

Steve Lee:
I think we need to update the presets with new timeouts too
@Codex can you take a look?

Codex:
Summary
• Extended the [illegible] preset to raise the new per-step timeout knobs so the combo shortcut still covers every train-loop timeout.
• Expanded unit tests for the combo preset and legacy flag passthrough to assert the added timeout fields.

Testing
• [illegible]

Arjun:
https://www.anthropic.com/news/claude-sonnet-5
@Superconductor add support for sonnet 5, make sure to update pricing table and all that

Introducing Claude Sonnet 5
Our most agentic Sonnet yet, with top-tier intelligence for coding and everyday professional work. (3 MB)

Superconductor:
Implemented Sonnet 5 support.

Changed:
• Added [illegible] with Sonnet pricing fields.
• Updated [illegible] to use claude-sonnet-5.
• Added Claude Code profile support and display name Sonnet 5.
• Added Anthropic prefill handling for claude-sonnet-5.
• Added a registry test for [illegible].

Validation passed:
• dip autoformat
• [illegible]

Everyone has a Slack bot. It’s not enough.

Interface text:
2 replies
See more
4 replies
Superconductor is working — View implementation

### Work with the same session across interfaces

A Slack request and a GitHub review comment connect to the same agent session. The agent view carries the review comment into Codex, letting work continue across interfaces.

[3:35](https://www.youtube.com/watch?v=OL7kfezynJM&t=215s) [Slack, GitHub, and an agent view show a shared coding session.](https://assets.ai.engineer/sites/aiecode2025/sha256/98ec9ffd03af98adab78c8b476e26db37cc79f09c9ed9f5ab0984c45c9775995.webp)

Lesson 1: Turn every human interface into an agent/human interface

Slack:
Arjun
https://www.anthropic.com/news/claude-sonnet-5
@Superconductor add support for sonnet 5, make sure to update pricing table and all that

anthropic.com
Introducing Claude Sonnet 5
Our most agentic Sonnet yet, with top-tier intelligence for coding and everyday professional work. (3 MB)

Superconductor is working — View implementation
Implemented Sonnet 5 support.

Changed:
• Added claude-sonnet-5 to LLM::Models::INFOS with Sonnet pricing fields.
• Updated ALL_AROUND to use claude-sonnet-5.
• Added Claude Code profile support and display name Sonnet 5.
• Added Anthropic prefill handling for claude-sonnet-5.
• Added a registry test for [illegible].

Validation passed:
• dip autoformat
• dip test test/models/coding_agent_profile_registry_test.rb test/lib/llm/chats/anthropic_test.rb

GitHub:
def prefill_unsupported_model?
/sc are you sure Sonnet 5 doesn't support prefill?

Agent view:
Arjun Singh
File: lib/llm/chats/anthropic.rb:74
@@ -72,7 +72,8 @@ def adaptive_thinking_
    end

    def prefill_unsupported_model?

are you sure Sonnet 5 doesn't support prefill?
Source: #3386 (comment)
Running Codex

Work with the same session from every relevant interface.

Interface text:
Comment on line R74
arjun810 1m ago
Author
superconductor-for-github[bot] 1m ago
4 replies

### Start and collaborate in Slack

In Slack, Superconductor shares a CPU-settings screenshot and submits a pull request; Arjun then asks to make 1 core the default.

[3:44](https://www.youtube.com/watch?v=OL7kfezynJM&t=224s) [A Slack conversation shows an agent sharing a screenshot and submitting a pull request.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c68ac55ea0f0a90b58ff9d94f179215e866ed8a7b5da5445d066c3fd687590e.webp)

Lesson 1: Turn every human interface into an agent/human interface

Start and Collaborate in Slack

Sergey  Yesterday at 5:25 PM
@Superconductor take screenshot

Superconductor APP  Yesterday at 5:28 PM
Screenshot captured with the custom CPU dropdown open:
cpu_dropdown.png (142 kB)

Arjun  2 minutes ago
@Superconductor pr

Superconductor APP  2 minutes ago
Creating pull request — I’ll reply with the link once it’s ready.
Pull request #3404 submitted!

Arjun  Just now
@Superconductor let’s make the default 1 core

Interface text:
Stellar Project Development Environment
Configure the setup commands, startup commands, and other settings for your project's development environment.
Rebuild Development Environment
Environment Setup Assistant
Provider
Select the provider for your development environment.
Runloop
Resources
Configure CPU, memory, and disk resources for your development environment.
CPU (cores)  Memory  Disk
2 cores  4 GB  10 GB
1 core
2 cores
4 cores
6 cores
8 cores
Terminal
[illegible]
Open Terminal
ruby  3.4
Secrets
Use secrets in commands as {{ secrets.SECRET_NAME }}.
[illegible]

### Continue in the desktop app

The desktop app shows the same agent session continuing from Slack, with the conversation beside the code changes and development environment settings. The speaker says the session keeps its context across interfaces.

[3:50](https://www.youtube.com/watch?v=OL7kfezynJM&t=230s) [A desktop app shows the agent conversation, code changes, and development environment settings.](https://assets.ai.engineer/sites/aiecode2025/sha256/9abd42a6995caf1f3bc3ea9e4fa13122247aef0c7601391c2b1cff50822b1f0b.webp)

Lesson 1: Turn every human interface into an agent/human interface

Continue in Desktop App

Arjun wrote:
“@Superconductor pr”
let’s make the default 1 core

Source: Slack

Codex
Changed the default CPU core count to 1 in project_infrastructure_config.rb.
Added a regression test in project_environment_form_test.rb proving a new project with no explicit infrastructure config renders 1 core by default.
Verified:
  dip test test/controllers/project_envir[illegible]
  dip autoformat
Result: 32 runs, 119 assertions, 0 failures, 0 errors, 0 skips; autoformat clean.

app/javascript/controllers/custom_select_controller.js
import { Controller } from "@hotwired/stimulus";

export default class extends Controller {
  static targets = ["dropdown", "input", "label", "option"];

  select(event) {
    const option = event.currentTarget;

    this.inputTarget.value = option.dataset.value;
    this.labelTarget.textContent = option.dataset.label;
    this.updateSelectedOption(option);
    this.closeDropdown();
  }

  updateSelectedOption(selectedOption) {
    this.optionTargets.forEach((option) => {
      const selected = option === selectedOption;
      option.classList.toggle("bg-base-300", selected);
      option.setAttribute("aria-selected", selected ? "true" : "false");
    });
  }

  closeDropdown() {
    if (this.hasDropdownTarget) {
      this.dropdownTarget.removeAttribute("open");
    }
  }
}

app/models/project_infrastructure_config.rb
class ProjectInfrastructureConfig
  include StoreModel::Model

  DEFAULT_VCPUS = 2

Superconductor Project Development Environment
Configure the setup commands, startup commands, and other settings for your project's development environment.
Rebuild Development Environment
Environment Setup Assistant

Provider
Select the provider for your development environment.
Runloop

Resources
Configure CPU, memory, and disk resources for your development environment.
CPU (cores): 2 cores
Memory: 4 GB
Disk: 10 GB
CPU options: 1 core, 2 cores, 4 cores, 6 cores, 8 cores
ruby 3.4

Secrets
Use secrets in commands as {{ secrets.SECRET_NAME }}.

Interface text:
Superconductor
Volition
Add support for 1 CPU core
#1 Codex - GPT-5.5 (Xhigh)
Update PR
App Preview
Chat
Full Diff
Guided Review
QA Check
Options
main
6 files changed
+156
Show work
Follow up with Codex...

### Finish in GitHub

A GitHub review comment reaches the same agent session used in earlier interfaces, carrying its context forward. The agent starts checking the current branch for CustomSelect references.

[3:55](https://www.youtube.com/watch?v=OL7kfezynJM&t=235s) [A GitHub review comment appears alongside the corresponding agent conversation.](https://assets.ai.engineer/sites/aiecode2025/sha256/ced4d33200055bde32c2cfcd5bfbfcfc724c226f2ed85a2dd67eada774b44001.webp)

Lesson 1: Turn every human interface into an agent/human interface

Finish in GitHub

Interface text:
96  -  { name: "project[infrastructure_config][vcpus]",
97  -    class: "w-full du-select mb-0", }
100 +  render CustomSelect.new(

Add a comment on line R100
Write  Preview
/sc do we use CustomSelect anywhere else?
Paste, drop, or click to add files
Cancel  Comment  Start a review

101 +    name: "project[infrastructure_config][vcpus]",
102 +    options: CPU_OPTIONS,
103 +    selected_value: cpu_value,

Superconductor  Volition  Superconductor
#1 Codex - GPT-5.5 (Xhigh)  5h: 1%  7d: 19%
Arjun Singh
File: app/views/components/project_environment_form.rb:100

@@ -90,11 +97,11 @@ def resources_selector(form) # rub[illegible]
    div(class: "flex flex-wrap gap-4 items-end") do
      div(class: "flex-1 min-w-24") do
        form.label :cpu, "CPU (cores)", class: "blo[illegible]
-       form.select :cpu,
-         [2, 4, 6, 8].map { |num_cores| [illegible]
-         { selected: cpu_value },
-         { name: "project[infrastructure[illegible]
-           class: "w-full du-select mb-0[illegible]
+       render CustomSelect.new(

do we use CustomSelect anywhere else?
Source: #3404 (comment)

I’ll check the codebase for CustomSelect references so the answer is grounded in the current branch, then I’ll report back directly.
Running Codex

### Make agent work visible and collaborative

Participant avatars show who has interacted with the shared agent session. A reviewer can also pose an inline question on the code diff and ask the agent for context.

[4:17](https://www.youtube.com/watch?v=OL7kfezynJM&t=257s) [An agent session shows participants, a shared conversation, and a code review with an inline question.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6cff96364fc5e41f36d73eb889c785a5fc8a5e81e61e08f4cfb3dd26de1a95c.webp)

Lesson 2: Make agent work visible and collaborative across the team.

Superconductor
Updated pull request with latest changes.

Sergey Karayev
Now tell a FRESH reviewer who is very familiar with the codebase the new and modified PATTERNS this PR introduces.

Not a laundry list of what the PR does. Only new/modified patterns, like if we changed some kind of workhorse method signature, etc. Stuff that a future coding agent might get tripped up by.

Codex
The review-relevant pattern changes are:

Agentic::MessageDelivery can now notify, but defaults not to
Agentic::MessageDelivery.new(..., notify_followers: false) remains the default internal-agent behavior. Callers must explicitly pass notify_followers: true when an agent-delivered message should surface to users.

This matters because MessageDelivery is used both for internal agent-to-agent plumbing and user-visible “DM” delivery.

Arjun Singh
Regarding config/routes.rb new line 162:

+ resources :workspace_member_chats, only: [:show]

what are the urls for these and workspace chats?

app/controllers/api/internal/workspace_chat_prompts_controller.rb
12 unmodified lines

private

def set_workspace_chat
-  @workspace_chat = GlobalID::Locator.locate_signed(params[:chat_id], for: "prompt")
+  @workspace_chat = GlobalID::Locator.locate_signed(params[:workspace_chat_id], for: "prompt")

Why is it this way?

end
end

app/controllers/workspace_chats_controller.rb
11 unmodified lines

before_action :set_projects, only: [:new, :create]
before_action :set_breadcrumbs

def new
  if existing_workspace_chat
    redirect_to workspace_chat_path(@workspace, existing_workspace_chat)
    return
  end

  @workspace_chat = @workspace.workspace_chats.new
  authorize! @workspace_chat

Interface text:
Superconductor > Volition > Superconductor > Implement Workspace Chat Feature with Chief of Staff Agent > #2
Codex - GPT-5.5 (Xhigh)
Previous · Next · View PR · Chat · Preview · Review
Full Diff · Guided Review · QA Check · Options · Collapse All
superconductor · main · 4 files changed · +26 -5
Viewed · Cancel · Add to Message · Send
Follow up with Codex...
https://www.superconductor.com

### Turn external signals into code

External signals include Slack conversations, customer meetings, bug reports and feature requests. The goal is to turn them into code the team can quickly evaluate.

[5:31](https://www.youtube.com/watch?v=OL7kfezynJM&t=331s) [Lesson 3 introduces turning external signals into code the team can quickly evaluate.](https://assets.ai.engineer/sites/aiecode2025/sha256/4edaaff11c8deddea132db7bfa3286c50222c9b5cfd8897333d4bcacb6bf3e42.webp)

Lesson 3: Turn every external signal into code your team can quickly evaluate.

### Sources of external signals

Signals are scattered across tools and teams. Even when coding agents can access those systems, people still coordinate what they should work on.

[6:05](https://www.youtube.com/watch?v=OL7kfezynJM&t=365s) [A list of external signal sources sits beside a diagram connecting workplace tools and teams.](https://assets.ai.engineer/sites/aiecode2025/sha256/d608f5bf74b0da3791de959994c9650b6e12e4f70e26d9bb90de1652bd404f74.webp)

Lesson 3: Turn every external signal into code your team can quickly evaluate.

• Slack
• Meetings
• Bug trackers
• Sales calls
• Bug reports
• Feature requests

Diagram labels: Design, Dev, Sales, Support, Product, Finance
Notification badges: 4, 3, 4, 4, 4, 4

### From meeting signals to a prototype

A meeting bot turns a four-hour meeting into a ticket. Alongside it, a prototype form asks for acceptance and verification criteria.

[6:40](https://www.youtube.com/watch?v=OL7kfezynJM&t=400s) [Screenshots show a meeting bot creating a ticket and a prototype form with acceptance and verification criteria.](https://assets.ai.engineer/sites/aiecode2025/sha256/7763b977b3bafd4af0ee03b2607279c06ec9583d21890018cd99f072f798dce8.webp)

Lesson 3: Turn every external signal into code your team can quickly evaluate.

Meeting Bot Creates Tickets

Meeting at AIE
Jun 30, 2026 at 9:21 PM  Lasted about 4 hours  Ended

Codex › Show work
Created 1 ticket:
#4280 Implement Eval-Driven Development Flow for Clear Acceptance and Verification Criteria
1 day ago by Superconductor from a Meeting

Arjun Singh
Summarize what happened in this meeting

Codex › Show work
This was a long conference/demo session for Superconductor. Sergey repeatedly demoed the core product: cloud-hosted coding agents, multiplayer agent sessions, live app previews, mobile/web/desktop access, Slack launch, guided review, QA checks, meeting assistant, email assistant, benchmarks, and the new chief of staff agent. A lot of the conversation was customer discovery: people

Screenshot of Prototype

Superconductor
What would you like Superconductor to work on?
Define acceptance and verification criteria...
Acceptance criteria
What must be true for the work to count as done?
Verification criteria
What should agents run, inspect, or prove before they finish?

Interface text:
Emails  Benchmark  Automations  Settings
1 run
superconductor  main

### Meeting assistant summary

Superconductor’s meeting bot shows a ticket and a generated summary beside the transcript of a four-hour expo meeting.

[6:52](https://www.youtube.com/watch?v=OL7kfezynJM&t=412s) [Meeting page with a generated ticket and summary beside the transcript.](https://assets.ai.engineer/sites/aiecode2025/sha256/276d757ba8e34f7a8b8f887643b5a2079ffdb7f23ed9e875e4072194cb17f141.webp)

Meeting at AIE
Jun 30, 2026 at 9:21 PM · Lasted about 4 hours · Ended

#4280 Implement Eval-Driven Development Flow for Clear Acceptance and Verification Criteria
1 waiting
1 day ago by Superconductor from a Meeting

Arjun Singh
Summarize what happened in this meeting

Codex · Show work · 10:59 AM
This was a long conference/demo session for Superconductor. Sergey repeatedly demoed the core product: cloud-hosted coding agents, multiplayer agent sessions, live app previews, mobile/web/desktop access, Slack launch, guided review, QA checks, meeting assistant, email assistant, benchmarks, and the new chief of staff agent. A lot of the conversation was customer discovery: people asked about terminal/CLI workflows, self-hosting or customer infra, GPU access, custom models, Zed integration, Discord, Figma/Linear context, multi-harness workflows, and stronger verification loops. Several concrete product ideas came up, especially around voice/transcript-driven ticket implementation, better session catch-up summaries/artifacts, agent rollback, QA feedback routing, custom review prompts, multiple review agents, role-aware chief of staff behavior, and automatic requester follow-up when features ship. There was also marketing/messaging discussion about moving away from the “software factory” metaphor toward orchestration/external signals/customer delight, plus a note to improve landing page messaging and diagrams. The meeting also included norm[illegible] booth chatter, lead scanning, recruiting notes, and follow-ups with prospects.

Meeting transcript:
i guess that boys thing huh that voice thing was won
i have a system called understudy right now that i'm working on which is basically like a system that i can encode my preferences and it was like kind of like a chief of staff basically to like monitor all of my agent sessions
so right now it's called understudy it's like the internal prototype
name i have and then what do you guys use for coding agents
on my team we use everything primarily we use our our own harness called it's really well suited for long running costs
so my general routine is i will say like
i'm about to go to bed
go in like like you have a bit of a weirdest superpowers like so i'll usually use like we have super powers module and amplifier so i want to kick off brainstorm and superpowers help to find out like what i'm looking for there's a visual brainstorming aspect to that where it'll say like
here's three variants of what you want to like choose one so that's all part of the like specking process and it will generate a spec and then usually what i'll do is something like say about to go to bed please like work for as long as you need to do this and our harness is like really well suited for long tasks like that so it'll go for 10 hours and like take huge swings and like building things
no what type stack does it tend to use
in terms of models we're using we we have our own like routing systems so it's like there's a configurable model routing what should i see what should we steal what should we steal from what's working well that's like not not commonly known yet what should we steam i see
i personally am a believer that like verification is is really really important if you want to have interesting if you want it so basically what i found is like you get three to five parallel agents yeah and then you sort of like hit a ceiling right like this it's just one way of proxying this is like what does the spend per user on tokens or like what is token throughput for user per builder on the team and like you i've seen that kind of flat by because everyone's sort of maxing out at running three to five pages yeah so you need some higher level of that's my experience is that your cf well just you don't want to switch between more than like four things because you just get confused yeah
yeah so you don't remember what the first thing was by the time you're on the fifth day and so then the question is like how do you how do you work around that i think one critical thing to do is like verification [cut off]

Interface text:
Superconductor > Volition > Superconductor > Meetings > Meeting at AIE
Delete
Follow up with Superconductor...
Browser tabs: Meeting at AIE - Superconductor; Ticket: Implement Eval-Driven [illegible]; eval_driven_ticket_form.png (PNG); Benchmark - Superconductor; Usage - Volition - Superconductor
www.superconductor.com/projects/[illegible]/meetings/[illegible]

### Tickets from a meeting

During a four-hour meeting, the bot created tickets and linked an existing one alongside the transcript. The linked ticket proposes extending transcript-driven ticket creation to email.

[7:08](https://www.youtube.com/watch?v=OL7kfezynJM&t=428s) [Meeting assistant lists created and linked tickets beside the transcript.](https://assets.ai.engineer/sites/aiecode2025/sha256/31eb025ef552b3ba418709518e36f84b3d03b44c55982032a34190ebac748bba.webp)

Meeting at AIE
Jun 30, 2026 at 9:21 PM · Lasted about 4 hours · Ended

Codex · Show work
Created 1 ticket:
#4201 Add feature to retrieve past meeting conversations/transcripts for AI context
1 waiting
1 day ago by Superconductor from a Meeting

Codex · Show work · 2:23 PM
Linked to 1 existing ticket:
#4196 Extend meeting/transcript-driven ticket creation flow to emails: ingest, analyze, and create tickets from email content.
1 waiting
1 day ago by Superconductor from a Meeting

Codex · Show work
Created 1 ticket:
#4202 Enable ticket implementation agents to create follow-up tickets when they identify additional work while implementing a ticket. For example, after ...
1 waiting
1 day ago by Superconductor from a Meeting

Meeting transcript:
i guess that boys thing huh that voice thing was won

i have a system called understudy right now that i'm working on which is basically like a system that i can encode my preferences and it was like kind of like a chief of staff basically to like monitor all of my agent sessions

so right now it's called understudy it's like the internal prototype

name i have and then what do you guys use for coding agents

on my team we use everything primarily we use our our own harness called it's really well suited for long running costs

so my general routine is i will say like

i'm about to go to bed

go in like like you have a bit of a weirdest superpowers like so i'll usually use like we have super powers module and amplifier so i want to kick off brainstorm and superpowers help to find out like what i'm looking for there's a visual brainstorming aspect to that where it'll say like

here's three variants of what you want to like choose one so that's all part of the like specking process and it will generate a spec and then usually what i'll do is something like say about to go to bed please like work for as long as you need to do this and our harness is like really well suited for long tasks like that so it'll go for 10 hours and like take huge swings and like building things

no what type stack does it tend to use

in terms of models we're using we we have our own like routing systems so it's like there's a configurable model routing what should i see what should we steal what should we steal from what's working well that's like not not commonly known yet what should we steam i see

i personally am a believer that like verification is is really really important if you want to have interesting if you want it so basically what i found is like you get three to five parallel agents yeah and then you sort of like hit a ceiling right like this it's just one way of proxying this is like what does the spend per user on tokens or like what is token throughput for user per builder on the team and like you i've seen that kind of flat by because everyone's sort of maxing out at running three to five pages yeah so you need some higher level of that's my experience is that your cf well just you don't want to switch between more than like four things because you just get confused yeah

yeah so you don't remember what the first thing was by the time you're on the fifth day and so then the question is like how do you how do you work around that i think one critical thing to do is like verification [illegible]

Interface text:
Superconductor · Volition · Superconductor · Meetings · Meeting at AIE
Delete
Follow up with Superconductor...
Browser tabs: Meeting at AIE - Superconductor; Ticket: Implement Eval-Driven [illegible]; eval_driven_ticket_form.png (PNG); Benchmark - Superconductor; Usage - Volition - Superconductor
www.superconductor.com/projects/[illegible]/meetings/[illegible]
120%

### Evaluation ticket from the meeting

The meeting bot created a ticket from a discussion about giving coding agents clear criteria to evaluate their work before declaring it done. The meeting summary appears alongside the transcript.

[7:24](https://www.youtube.com/watch?v=OL7kfezynJM&t=444s) [Meeting page shows an evaluation criteria ticket above a meeting summary.](https://assets.ai.engineer/sites/aiecode2025/sha256/29916a30d731322b8985841464e8195c9e4601eb4d9c0598752579b2c2cfd273.webp)

Meeting at AIE
Jun 30, 2026 at 9:21 PM · Lasted about 4 hours · Ended

Codex · Show work · 6:46 PM
Created 1 ticket:
#4282 Implement Eval-Driven Development Flow for Clear Acceptance and Verification Criteria
1 waiting
1 day ago by Superconductor from a Meeting

Arjun Singh
Summarize what happened in this meeting

Codex · Show work
This was a long conference/demo session for Superconductor. Sergey repeatedly demoed the core product: cloud-hosted coding agents, multiplayer agent sessions, live app previews, mobile/web/desktop access, Slack launch, guided review, QA checks, meeting assistant, email assistant, benchmarks, and the new chief of staff agent. A lot of the conversation was customer discovery: people asked about terminal/CLI workflows, self-hosting or customer infra, GPU access, custom models, Zed integration, Discord, Figma/Linear context, multi-harness workflows, and stronger verification loops. Several concrete product ideas came up, especially around voice/transcript-driven ticket implementation, better session catch-up summaries/artifacts, agent rollback, QA feedback routing, custom review prompts, multiple review agents, role-aware chief of staff behavior, and automatic requester follow-up w[illegible] features ship. There was also marketing/messaging discussion about moving away from the “software factory” metaphor toward

Meeting transcript:
i guess that boys thing huh that voice thing was won
i have a system called understudy right now that i'm working on which is basically like a system that i can encode my preferences and it was like kind of like a chief of staff basically to like monitor all of my agent sessions
so right now it's called understudy it's like the internal prototype
name i have and then what do you guys use for coding agents
on my team we use everything primarily we use our our own harness called it's really well suited for long running costs
so my general routine is i will say like
i'm about to go to bed
go in like like you have a bit of a weirdest superpowers like so i'll usually use like we have super powers module and amplifier so i want to kick off brainstorm and superpowers help to find out like what i'm looking for there's a visual brainstorming aspect to that where it'll say like
here's three variants of what you want to like choose one so that's all part of the like specking process and it will generate a spec and then usually what i'll do is something like say about to go to bed please like work for as long as you need to do this and our harness is like really well suited for long tasks like that so it'll go for 10 hours and like take huge swings and like building things
no what type stack does it tend to use
in terms of models we're using we we have our own like routing systems so it's like there's a configurable model routing what should i see what should we steal what should we steal from what's working well that's like not not commonly known yet what should we steam i see
i personally am a believer that like verification is is really really important if you want to have interesting if you want it so basically what i found is like you get three to five parallel agents yeah and then you sort of like hit a ceiling right like this it's just one way of proxying this is like what does the spend per user on tokens or like what is token throughput for user per builder on the team and like you i've seen that kind of flat by because everyone's sort of maxing out at running three to five pages yeah so you need some higher level of that's my experience is that your cf well just you don't want to switch between more than like four things because you just get confused yeah
yeah so you don't remember what the first thing was by the time you're on the fifth day and so then the question is like how do you how do you work around that i think one critical thing to do is like verification
[illegible]

Interface text:
Superconductor · Volition · Superconductor · Meetings · Meeting at AIE
Delete
Follow up with Superconductor...
Meeting at AIE - Superconductor
Ticket: Implement Eval-Driven [illegible]
eval_driven_ticket_form.png (PNG)
Benchmark - Superconductor
Usage - Volition - Superconductor
www.superconductor.com/projects/[illegible]/meetings/[illegible]
120%

### Evaluation ticket implementation

Codex worked on the meeting-generated ticket and returned a screenshot of the form with acceptance and verification criteria. The speaker describes it as a concrete prototype to try, not necessarily the version he will ship.

[7:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=471s) [Implementation view with a code diff and a small preview of the new ticket form.](https://assets.ai.engineer/sites/aiecode2025/sha256/197e2937ccf92106265206e93da072f98d83dfd9200e68b14a8fd4c4f8d23356.webp)

All passed.

Arjun Singh
can you take a screenshot of this new form?

Codex
Here’s the screenshot of the expanded new ticket form:

Embedded screenshot:
What would you like Superconductor to work on?
Define acceptance and verification criteria...
Acceptance criteria
[illegible]
Verification criteria
[illegible]
Create Ticket

app/controllers/ticket_implementations_controller.rb
109 unmodified lines

110   params.fetch(:implementations, {}).permit(*allowed_keys)
111 end
112
113 def launch_requested_implementations
114   assign_eval_driven_development_criteria
115   @ticket.launch_implementations(implementations_params.to_h, creator: current_user)
116 end
117
118 def eval_driven_development_params
119   params.fetch(:eval_driven_development, {}).permit(:acceptance_criteria, :verification_criteria)
120 end
121
122 def assign_eval_driven_development_criteria
123   return unless params.key?(:eval_driven_development)
124
125   @ticket.assign_eval_driven_development_criteria(**eval_driven_development_params.to_h.symbolize_keys)
126   @ticket.save!
127 end
128
129 def execute_stop_agent
130   agent_name = @ticket_implementation.profile_display_name
131   agent_execution = @ticket_implementation.orchestration.agent_executions.create!(
132     status: :pending_dispatch,

34 unmodified lines

Interface text:
Superconductor
Volition > Superconductor > Implement Eval-Driven Development Flow for Clear Acceptance and Verification Criteria > #1
#1 Codex - GPT-5.5 (High)
5h: 11%  7d: 21%
Submit PR  Chat  Preview  Review
Full Diff  Guided Review  QA Check  Options  Collapse All  0%
superconductor  main  12 files changed  +276 -1
+12  Viewed
Show work
Follow up with Codex...
Recent Activity
Docs  Support  Account

## Full transcript

[0:00](https://www.youtube.com/watch?v=OL7kfezynJM&t=0s) [upbeat music] All right. Hey, everyone, I'm Arjun Singh.

[0:15](https://www.youtube.com/watch?v=OL7kfezynJM&t=15s) Today, I'm gonna 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 gonna see that a lot of people are just talking about putting the agents at the center of everything.

[0:27](https://www.youtube.com/watch?v=OL7kfezynJM&t=27s) Makes sense. They're really powerful and 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 or more, more productive or whatever.

[0:37](https://www.youtube.com/watch?v=OL7kfezynJM&t=37s) And so we're gonna really focus on how the people fit into these agentic workflows.

[0:41](https://www.youtube.com/watch?v=OL7kfezynJM&t=41s) So just a little bit about us first. So our team has worked together building software for over a decade. Uh, my co-founder, Sergey and I, we met in the PhD program at Berkeley.

[0:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=51s) 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, helped instructors grade their students' work.

[1:04](https://www.youtube.com/watch?v=OL7kfezynJM&t=64s) 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.

[1:15](https://www.youtube.com/watch?v=OL7kfezynJM&t=75s) And I think it's kind of an interesting experiment because o- 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

[1:29](https://www.youtube.com/watch?v=OL7kfezynJM&t=89s) agents. So today I'm gonna talk to you about how, you know, we, we-- the lessons we learned from kinda solving those friction points and solving those bottlenecks.

[1:38](https://www.youtube.com/watch?v=OL7kfezynJM&t=98s) And in the talk description, I mentioned, uh, five lessons, and I'm gonna be an engineer and start from zero and add a sixth one in there. Um, the first one I'm gonna start with is just to be model and harness agnostic.

[1:49](https://www.youtube.com/watch?v=OL7kfezynJM&t=109s) So there's a few reasons for that. The best model and harness can change weekly. It could change 'cause a new one comes out. It could change 'cause the best one got taken away.

[1:58](https://www.youtube.com/watch?v=OL7kfezynJM&t=118s) 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.

[2:09](https://www.youtube.com/watch?v=OL7kfezynJM&t=129s) They're much cheaper. Um, and you wanna be able to kind of explore with them and integrate them without, again, having to change your entire workflow.

[2:16](https://www.youtube.com/watch?v=OL7kfezynJM&t=136s) And 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, you're-- so you're working on things for a reason.

[2:25](https://www.youtube.com/watch?v=OL7kfezynJM&t=145s) You're trying to make your customers' lives better, make your product better, delight your customers, and they wanna sell you more tokens. And you might be happy to pay for as many tokens as it takes, but you don't wanna pay for more than that.

[2:36](https://www.youtube.com/watch?v=OL7kfezynJM&t=156s) And so, again, kind of being able to switch between things lets you stay in control of all of that.

[2:43](https://www.youtube.com/watch?v=OL7kfezynJM&t=163s) 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 gonna leave things with you that I think are really important, um, for you to be able to work collaboratively, effectively.

[2:58](https://www.youtube.com/watch?v=OL7kfezynJM&t=178s) 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.

[3:09](https://www.youtube.com/watch?v=OL7kfezynJM&t=189s) Nobody else can talk to that agent. So the first place people go to kind of expose more interfaces for them is Slack. Claude has a Slack bot. Codex has a Slack bot.

[3:19](https://www.youtube.com/watch?v=OL7kfezynJM&t=199s) We have a Slack bot. It's really cool. You can say, "@Superconductor, do XYZ." It does it. Somebody else can talk to it. But it's not enough 'cause now we've taken it from trapped on somebody's laptop to kinda trapped in Slack.

[3:30](https://www.youtube.com/watch?v=OL7kfezynJM&t=210s) And a lot of work happens in Slack, so that's better than, than, than nothing, but certainly not all work happens in Slack.

[3:36](https://www.youtube.com/watch?v=OL7kfezynJM&t=216s) 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.

[3:45](https://www.youtube.com/watch?v=OL7kfezynJM&t=225s) And so one possible flow is you start and collaborate on a session in Slack,

[3:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=231s) and then maybe you continue in a kinda more engineer-focused environment in the desktop app or the mobile app, and then you can finish it up in GitHub. And it re-- the important thing here is it's 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

[4:05](https://www.youtube.com/watch?v=OL7kfezynJM&t=245s) and talk to it from GitHub. It's the same session. It's got the same context.

[4:10](https://www.youtube.com/watch?v=OL7kfezynJM&t=250s) 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 kinda app view and, you know, Sergey made this ticket.

[4:25](https://www.youtube.com/watch?v=OL7kfezynJM&t=265s) I've been talking to the same ticket. A growth person hopped in as well. And so you can kinda see at the top here all the different people that interacted with it.

[4:31](https://www.youtube.com/watch?v=OL7kfezynJM&t=271s) 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 not technical people, right? So it's like, you know, our customer support person created a ticket.

[4:42](https://www.youtube.com/watch?v=OL7kfezynJM&t=282s) It's working really well. I wanna understand, like, has this been vetted by an engineer or not, and kinda see who's involved really easily.

[4:49](https://www.youtube.com/watch?v=OL7kfezynJM&t=289s) 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 kinda get my notification on GitHub and respond to me.

[4:59](https://www.youtube.com/watch?v=OL7kfezynJM&t=299s) The answer to the question's almost certainly in this thread.

[5:04](https://www.youtube.com/watch?v=OL7kfezynJM&t=304s) I also don't wanna read the entire thread, so I can just ask, ask the agent. Or

[5:09](https://www.youtube.com/watch?v=OL7kfezynJM&t=309s) 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 a screenshot or video or other, and you can see it from everywhere.

[5:23](https://www.youtube.com/watch?v=OL7kfezynJM&t=323s) So again, you don't have to worry about, like, oh, where is that thing? I gotta go to GitHub to see the image, or I gotta go to Slack to see the image.

[5:28](https://www.youtube.com/watch?v=OL7kfezynJM&t=328s) It's just everywhere. Work is visible everywhere. You can collaborate from anywhere.

[5:35](https://www.youtube.com/watch?v=OL7kfezynJM&t=335s) So the third lesson, um, I'm gonna talk about here is to turn every external signal into code that your team can quickly evaluate. And I was hoping to show this live, but the Wi-Fi is not quite there, so I'm gonna show you something from yesterday.

[5:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=351s) But what do I mean by external signal?

[5:53](https://www.youtube.com/watch?v=OL7kfezynJM&t=353s) 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 a bug tracker, a bug report from a customer, an email, feature request.

[6:06](https://www.youtube.com/watch?v=OL7kfezynJM&t=366s) And right now what's happening is, like, all that stuff is already exists. It's, 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?

[6:19](https://www.youtube.com/watch?v=OL7kfezynJM&t=379s) It's like it, it's still kinda stuck everywhere. And so, like, some humans are involved in, like, kind of taking stuff from one place and telling it, "Solve email number forty-eight or ticket number [REDACTED:generic_id]," but that's still a lot of coordination.

[6:33](https://www.youtube.com/watch?v=OL7kfezynJM&t=393s) 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 kinda act on them.

[6:41](https://www.youtube.com/watch?v=OL7kfezynJM&t=401s) And my favorite one, the most fun one, is what we call our meeting bot.

[6:45](https://www.youtube.com/watch?v=OL7kfezynJM&t=405s) And so I'm gonna sw-switch over to my browser here for a second.

[6:50](https://www.youtube.com/watch?v=OL7kfezynJM&t=410s) 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 four-hour meeting of a Google Meet.

[6:59](https://www.youtube.com/watch?v=OL7kfezynJM&t=419s) You just kinda invite the bot to your m-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.

[7:10](https://www.youtube.com/watch?v=OL7kfezynJM&t=430s) If it finds existing work, it'll link to it, right? So it's not gonna just, like, create new work if it's something you're 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.

[7:22](https://www.youtube.com/watch?v=OL7kfezynJM&t=442s) 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 on what to do with it.

[7:30](https://www.youtube.com/watch?v=OL7kfezynJM&t=450s) And so it's kinda nice 'cause the last idea that was here was someone saying, "Hey, like, when I work with coding agents, I wanna 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."

[7:43](https://www.youtube.com/watch?v=OL7kfezynJM&t=463s) And, um, so they had that idea. The bot just picked up on it. N-none of us did anything manually. It created this ticket

[7:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=471s) 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 kinda modified our ticket form to add these two new fields of acceptance criteria.

[8:03](https://www.youtube.com/watch?v=OL7kfezynJM&t=483s) Now I'm gonna-- am I gonna 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.

[8:14](https://www.youtube.com/watch?v=OL7kfezynJM&t=494s) And so it takes, like, this, you know, y- you know, your hundreds or thousands of ideas that are everywhere and it helps you kinda move with the speed of what your customers are asking you for and what they're thinking.

[8:23](https://www.youtube.com/watch?v=OL7kfezynJM&t=503s) And, um, it's really fun because every time we have an onboarding or a 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 very minimal intervention.

[8:38](https://www.youtube.com/watch?v=OL7kfezynJM&t=518s) So we talk, stuff comes out, we look at it, we ship it. It's so much fun.

[8:45](https://www.youtube.com/watch?v=OL7kfezynJM&t=525s) Put this back. So the next thing I'm gonna mention is that, you know, the, 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.

[9:10](https://www.youtube.com/watch?v=OL7kfezynJM&t=550s) So there's several reasons why this is important. So the first one is to eliminate what some people are calling lid anxiety. You wanna be able to close your laptop.

[9:17](https://www.youtube.com/watch?v=OL7kfezynJM&t=557s) You've probably seen people running around the conference 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 car as they're driving home.

[9:29](https://www.youtube.com/watch?v=OL7kfezynJM&t=569s) This was actually probably the impetus for, for me and for a few people on our team to even start working on this. You know, last year I started working with Claude Co- with Claude Code a lot.

[9:39](https://www.youtube.com/watch?v=OL7kfezynJM&t=579s) I had a, I think at the time, like, [REDACTED:age]. I, like, didn't want to, like, be tied to my laptop or have that stress. Just like I, I don't, I, I don't ever wanna think about whether I can, like, step away from a laptop or not.

[9:50](https://www.youtube.com/watch?v=OL7kfezynJM&t=590s) 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.

[10:00](https://www.youtube.com/watch?v=OL7kfezynJM&t=600s) 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.

[10:12](https://www.youtube.com/watch?v=OL7kfezynJM&t=612s) 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 their laptop.

[10:23](https://www.youtube.com/watch?v=OL7kfezynJM&t=623s) Their laptops, unless you have, like, impeccable hygiene, probably have a bunch of stuff on it that you don't want the LLMs or the agents to have access to. And yeah, like, everybody's working on these sandboxes and approval flows, and so you...

[10:35](https://www.youtube.com/watch?v=OL7kfezynJM&t=635s) 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.

[10:50](https://www.youtube.com/watch?v=OL7kfezynJM&t=650s) 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.

[10:57](https://www.youtube.com/watch?v=OL7kfezynJM&t=657s) And so when you say, "Hey, you know, wipe the staging 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.

[11:07](https://www.youtube.com/watch?v=OL7kfezynJM&t=667s) 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.

[11:24](https://www.youtube.com/watch?v=OL7kfezynJM&t=684s) To go one step further on that, um, it's not just, "Hey, 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 that you shouldn't be able to.

[11:38](https://www.youtube.com/watch?v=OL7kfezynJM&t=698s) 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 any time it tries to access something that it shouldn't, it just pops up and says, "Hey, tried to access something.

[11:49](https://www.youtube.com/watch?v=OL7kfezynJM&t=709s) Do you wanna give it access? Maybe you're trying to integrate a new vendor and need documentation." And you can do it on a per ticket basis or for the whole project.

[11:57](https://www.youtube.com/watch?v=OL7kfezynJM&t=717s) 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 YOLO mode.

[12:13](https://www.youtube.com/watch?v=OL7kfezynJM&t=733s) 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.

[12:26](https://www.youtube.com/watch?v=OL7kfezynJM&t=746s) But we've gotten our support people, our growth people to actually be meaningfully impacting the product by just talking to users, seeing bugs, experiencing themselves, and just go to Slack or the app itself and say, "Hey, fix this."

[12:40](https://www.youtube.com/watch?v=OL7kfezynJM&t=760s) They fix it, screenshots are shown, engineer gets it, gets merged. Without that, they'd have to put it in Linear, and engineer would eventually pick it up, and a PM would triage it or whatever.

[12:51](https://www.youtube.com/watch?v=OL7kfezynJM&t=771s) None of that here. You just ask for it, and it's done.

[12:55](https://www.youtube.com/watch?v=OL7kfezynJM&t=775s) 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 kinda sandbox environment used to be really, really painful.

[13:05](https://www.youtube.com/watch?v=OL7kfezynJM&t=785s) But the agents have gotten better. We have our own environment setup assistant that kind of takes your project and gets it to work under 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 Claude Code or Codex to do this for you.

[13:19](https://www.youtube.com/watch?v=OL7kfezynJM&t=799s) You don't have to use us, but, you know, we think it's the best way.

[13:25](https://www.youtube.com/watch?v=OL7kfezynJM&t=805s) And the last lesson is to benchmark agents on your code base. So, um, the way we do this is 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.

[13:39](https://www.youtube.com/watch?v=OL7kfezynJM&t=819s) You pick the agents you wanna use and benchmark, and then you get a quality versus cost and time breakdown in your code base. Now, why do you wanna do this?

[13:47](https://www.youtube.com/watch?v=OL7kfezynJM&t=827s) There's, there's many reasons, but one is that if you're kinda going off the public benchmarks, SWE-bench or Terminal-Bench or other stuff, like those tasks may have absolutely nothing to do with your task.

[13:55](https://www.youtube.com/watch?v=OL7kfezynJM&t=835s) 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.

[14:05](https://www.youtube.com/watch?v=OL7kfezynJM&t=845s) And I'm gonna swap over to my browser one more time here.

[14:10](https://www.youtube.com/watch?v=OL7kfezynJM&t=850s) So this is-- the-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.

[14:23](https://www.youtube.com/watch?v=OL7kfezynJM&t=863s) 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.

[14:35](https://www.youtube.com/watch?v=OL7kfezynJM&t=875s) The open stuff has been getting better and better over time, but they're kinda slow. This is for our code base again. I'm not trying to make any general claims here.

[14:43](https://www.youtube.com/watch?v=OL7kfezynJM&t=883s) 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 caused us a change of behavior.

[14:53](https://www.youtube.com/watch?v=OL7kfezynJM&t=893s) 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 kinda matched our vibe check.

[15:01](https://www.youtube.com/watch?v=OL7kfezynJM&t=901s) We wanted to kind of like have hard data too. We switched our default to Codex at that time. Then Fable came out, and it was great. Kinda switched our default to that for, like, the few days we had it, and then it went away, and we switched back to Codex.

[15:13](https://www.youtube.com/watch?v=OL7kfezynJM&t=913s) But the most important thing is, like, because we're agnostic, like, none of that had any meaningful disruption on our work. Like, we were able to just kinda switch back and forth really easily.

[15:20](https://www.youtube.com/watch?v=OL7kfezynJM&t=920s) So next day something new comes out, see if it's good, and go.

[15:26](https://www.youtube.com/watch?v=OL7kfezynJM&t=926s) And the last thing I wanna mention around that is, like, I don't know if this resonates with you all, but I have a lot of friends that are like, "Okay, I heard MiniMax is good, and I heard, you know, GLM is good, and Kimi K2 is good, but, like, haven't had the time to try it out.

[15:38](https://www.youtube.com/watch?v=OL7kfezynJM&t=938s) Everybody keeps telling me I need to 'cause it's so much better and faster and cheaper." And you kinda 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.

[15:48](https://www.youtube.com/watch?v=OL7kfezynJM&t=948s) So, like, what's... You know, I just wasted those two hours. This kinda eliminates that. It helps you kinda stay on the cutting edge really, like, seamlessly.

[15:57](https://www.youtube.com/watch?v=OL7kfezynJM&t=957s) Let me go back. So what that kinda turned into us-- for us is, you know, essentially a hundred percent, like ninety-nine point nine percent of our pull requests are, like, heavily agent-generated.

[16:08](https://www.youtube.com/watch?v=OL7kfezynJM&t=968s) 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.

[16:16](https://www.youtube.com/watch?v=OL7kfezynJM&t=976s) Um, you know, for our, our, our relatively small team, we had ten and a half billion tokens over the past month. And you can kinda see what we were saying about Claude here.

[16:24](https://www.youtube.com/watch?v=OL7kfezynJM&t=984s) It's a little small, so I apologize, but we had thirty-three hundred Claude Code runs that cost ten thousand dollars in token billing. We have plans, so we didn't spend ten thou-- ten thousand dollars on it.

[16:34](https://www.youtube.com/watch?v=OL7kfezynJM&t=994s) 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.

[16:45](https://www.youtube.com/watch?v=OL7kfezynJM&t=1005s) More and more is happening through GLM-5.2. Gonna invest in that. And 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.

[17:00](https://www.youtube.com/watch?v=OL7kfezynJM&t=1020s) But how do, how does like some third party know what to route for your code base? Like, this is a way that you know what's gonna work best for which task for your, for your project, and working on kinda automatically routing that for you.

[17:13](https://www.youtube.com/watch?v=OL7kfezynJM&t=1033s) So I'm gonna leave you with a few recommendations.

[17:15](https://www.youtube.com/watch?v=OL7kfezynJM&t=1035s) 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.

[17:24](https://www.youtube.com/watch?v=OL7kfezynJM&t=1044s) 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.

[17:36](https://www.youtube.com/watch?v=OL7kfezynJM&t=1056s) Obviously, we think Superconductor 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.

[17:46](https://www.youtube.com/watch?v=OL7kfezynJM&t=1066s) 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.

[17:59](https://www.youtube.com/watch?v=OL7kfezynJM&t=1079s) 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 superconductor.com, or you can email me with any questions at [REDACTED:email_address].

[18:08](https://www.youtube.com/watch?v=OL7kfezynJM&t=1088s) Um, I will be out in the back as well for any questions. Thanks so much. [clapping]

[18:16](https://www.youtube.com/watch?v=OL7kfezynJM&t=1096s) 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 are here 'cause you signed up through for that, just meet us outside, and we will announce the winner.

[18:26](https://www.youtube.com/watch?v=OL7kfezynJM&t=1106s) Thank you. [outro music]
