Stack Overflow Lets AI Agents Post Answers Under Human User Scores

Stack Overflow - From Idea to Product | DevDay 2026 — OpenAI

OpenAI

Stack Overflow is opening its public forums to autonomous AI agents to empirically test and publish code fixes, binding non-human contributions to developer reputation scores to preserve platform trust.

AI-assisted summary of Stack Overflow - From Idea to Product | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • Stack Overflow detailed a dual-track product strategy powered by OpenAI Codex, balancing enterprise knowledge intelligence in Stack Internal with experimental autonomy in Stack Overflow for Agents (SOFA). (1:34)
  • For enterprise deployments, the team used Codex to synthesize cross-platform data silos into unified API 'archetypes' in days rather than weeks, shifting senior engineering focus toward data authority and freshness heuristics. (3:41)
  • Stack Overflow for Agents enables AI agents to transition from passive consumers to active contributors, publishing 'TIL' write-ups, architecture blueprints, and empirical test outcomes directly to the platform. (8:43)
  • Agent autonomy on Stack Overflow is fully configurable, allowing human developers to require manual review or permit autonomous posting while staking their own platform reputation on the agent's contributions. (10:30)

Detailed notes

## Background Published by OpenAI on YouTube on October 7, 2026, this DevDay 2026 session covers how small teams at Stack Overflow utilized Codex to accelerate R&D and build new products. The presentation details the development of Stack Overflow for Agents and the architectural reimagining of enterprise-grade Stack Internal.

## TL;DR Alex Lotto, VP of Product at Stack Overflow, reveals how the platform uses OpenAI Codex across two distinct engineering tracks: Stack Internal and Stack Overflow for Agents (SOFA). For the enterprise track, Codex synthesized disparate knowledge sources across tools like Slack and Confluence into unified data archetypes, freeing engineers to focus on trust and freshness heuristics. For the experimental SOFA track, the team built an agent-native architecture where autonomous agents can run empirical tests, author new solutions, and tie their contributions directly back to human reputation profiles with configurable oversight.

## Atmosphere & style The presentation strikes an engaging, pragmatic tech-conference tone, opening with lighthearted banter about California weather before transitioning into detailed engineering strategy. Lotto delivers a lucid, grounded talk that balances legacy platform nostalgia with cutting-edge system architecture. The mood is both candid and optimistic, capturing a legendary developer hub actively redefining its identity in an agent-first era.

## Bulletin - [01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) Stack Overflow detailed a dual-track product strategy powered by OpenAI Codex, balancing enterprise knowledge intelligence in Stack Internal with experimental autonomy in Stack Overflow for Agents (SOFA). - [03:41](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=221s) For enterprise deployments, the team used Codex to synthesize cross-platform data silos into unified API 'archetypes' in days rather than weeks, shifting senior engineering focus toward data authority and freshness heuristics. - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) Stack Overflow for Agents enables AI agents to transition from passive consumers to active contributors, publishing 'TIL' write-ups, architecture blueprints, and empirical test outcomes directly to the platform. - [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) Agent autonomy on Stack Overflow is fully configurable, allowing human developers to require manual review or permit autonomous posting while staking their own platform reputation on the agent's contributions.

## Key takeaways - [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) Stack Overflow is re-architecting its product portfolio to support an agent-first ecosystem alongside its long-standing public Q&A platform. - [01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) The company applies Codex across two contrasting development tracks: strict architectural guardrails for enterprise tools and open-ended exploration for greenfield prototyping. - [01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) Stack Internal targets high-compliance enterprise deployments spanning 150 to 50,000 seats across on-premises and hybrid cloud architectures. - [03:41](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=221s) Codex helped design generalized 'archetypes' that abstract fragmented knowledge sources across Slack, Teams, Google Docs, Confluence, Jira, and Notion into standardized API layers. - [03:41](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=221s) Automating ingestion connector logic compressed weeks of development into days, allowing engineers to focus on algorithmic trust and recency scoring. - [08:05](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=485s) Industry documentation consumption is shifting away from human browser browsing toward programmatic ingestion by autonomous software agents. - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) Stack Overflow for Agents (SOFA) was built on a distinct architecture to iterate rapidly on agent-human collaboration mechanics without legacy platform constraints. - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) Codex proposed tying agent identities directly to human users after analyzing Stack Overflow's brand history, community guidelines, and ethos. - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) Agents can act as active contributors rather than passive lurkers, submitting production-tested bug fixes as 'TIL' posts and publishing architecture blueprints. - [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) Agent actions are tethered to the human owner's real-world identity and Stack Overflow reputation points to maintain platform accountability. - [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) Developers can establish topic-based autonomy settings, requiring manual approval for high-risk domains while granting full autonomous posting for others. - [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) Agents close the feedback loop by testing unverified Q&A suggestions in staging or production environments and reporting empirical pass/fail results back to threads. - [11:53](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=713s) Stack Overflow launched Stack Overflow for Agents for free public testing alongside the rollout of its upgraded enterprise intelligence layer.

## Detailed walkthrough ### [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) Introducing Stack Overflow’s Next Chapter with Codex

The session opens with an introduction from OpenAI’s Developer Experience team, setting up an inside look at how long-time developer cornerstone Stack Overflow is integrating Codex directly into its core product development lifecycle. The host welcomes Alex Lotto, VP of Product at Stack Overflow, to discuss how their teams leverage Codex both for internal acceleration and for rethinking the company's place in an "agent-first world." Taking the stage, Lotto breaks the ice with light banter about the chilly California temperatures, joking that as a Canadian, he should handle the cold much better than he actually does: "Apparently not. Very terrible Canadian."

Lotto outlines his role overseeing Stack Overflow's complete product portfolio. While best known for its legendary public Q&A platform—which Lotto quips most developers in the audience have relied on at least "once upon a time" in their careers—the product strategy now spans two distinct, forward-looking initiatives: Stack Internal and Stack Overflow for Agents.

[01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) Two Ends of the Product Spectrum: Stack Internal vs. SOFA

When asked how Codex fits into Stack Overflow's engineering roadmap, Lotto frames the work as occupying two polar ends of the software development lifecycle spectrum:

```mermaid flowchart TD accTitle: Stack Overflow Dual Product Strategy with Codex accDescr: Diagram illustrating the two contrasting product tracks and their Codex development approaches.

subgraph Enterprise ["Enterprise Track: Stack Internal"] E1["Strict Architectural Contracts"] --> E2["Prescriptive Codex Guardrails"] E2 --> E3["Multi-Source Ingestion & Permissions"] E3 --> E4["Enterprise Deployment<br>(150 to 50k seats, On-Prem/Cloud)"] end

subgraph Experimental ["Experimental Track: SOFA"] S1["Hypothesis-Driven / Scrappy"] --> S2["Codex Given Free Reign<br>('Go Rogue')"] S2 --> S3["Net-New Agent-First Architecture"] S3 --> S4["Individual / Autonomous Agent Workflows"] end ```

On one side lies Stack Internal, an enterprise-grade knowledge intelligence platform built for massive, high-compliance deployments ranging from 150 seats up to 50,000 seats at large financial institutions. This product demands strict on-premises and hybrid cloud support, rigid authorization models, and airtight governance. On the opposite extreme sits Stack Overflow for Agents (internally dubbed "SOFA"), a scrappy, highly experimental product designed from the ground up for individual developers and autonomous agents interacting directly with programmatic knowledge bases.

Lotto explains that these opposing product goals dictated radically different ways of engaging with Codex: - **SOFA (Experimental):** Product and engineering granted Codex broad creative autonomy. Aside from basic architectural "golden paths," the team let Codex "go rogue" to explore container setups, architectural constraints, and rapid greenfield prototyping. - **Stack Internal (Enterprise):** The team acted far more prescriptively, establishing rigid boundaries and structural contracts before letting Codex write service logic, ensuring strict adherence to existing contracts and human-in-the-loop oversight.

[03:41](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=221s) Enterprise Constraints and the "Archetype" Knowledge Engine

Diving deeper into Stack Internal, Lotto emphasizes that building enterprise knowledge tools in an era beyond simple keyword searching or grep requires solving deep contextual and security challenges. Enterprises produce sprawling, fragmented knowledge every day across Slack, Microsoft Teams, Google Docs, Confluence, Jira, and Notion. Each platform features unique data formats, varying edit frequencies, distinct sharing permissions, and custom organizational configurations. Simply pulling this data into an LLM risks severe data leakage if access controls are not respected across every layer.

To eliminate weeks of bespoke connector plumbing, the team used Codex to identify and synthesize cross-platform patterns into generalized "archetypes": - **Pattern recognition across silos:** Codex helped design standardized API layers around conceptual archetypes, such as a unified "document archetype" capable of abstracting Google Docs, Microsoft Teams attachments, Confluence pages, and Notion workspaces simultaneously. - **Rapid velocity:** Architectural logic and source mappings that would traditionally take engineering teams weeks and weeks to draft were synthesized with Codex in a matter of days. - **Shifting focus to trust and verification:** Freeing senior engineers from mundane data extraction allowed them to focus on Stack Overflow's core differentiator: data trust, freshness, and authority scoring. Engineers could concentrate on algorithmic heuristics—such as establishing whether an operational Slack message from Alex yesterday outweighs a conflicting Slack message from March—rather than worrying about how to ingest raw data payloads.

[08:05](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=485s) Designing for an Agent-First Web

Transitioning to Stack Overflow for Agents (SOFA), the host points out an industry-wide paradigm shift observed at OpenAI: documentation is increasingly consumed not by human eyes scrolling a web browser, but by autonomous agents directed to scrape, parse, and act on reference materials. Lotto reflects on what this transformation means for Stack Overflow, a platform that has spent over a decade thriving as a human-led, community-moderated forum, and how they must now re-architect their systems to accommodate both human contributors and non-human agents.

[08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) Stack Overflow for Agents: From Lurking to Contributing

Stack Overflow has always been defined by being accessible and open by default, but the engineering team's current mandate is to rethink the next chapter: how to build for a world where humans and autonomous agents consume and contribute knowledge together. This paradigm shift fundamentally changes the game for Stack Overflow. The team had to grapple with core mechanics of the platform: how to involve community moderators, how to manage questions and answers, and how to deal with familiar developer pain points like "having a question closed as a duplicate." To explore solutions without being slowed down by legacy systems, they created *Stack Overflow for Agents* as an experimental initiative running on a separate architecture, allowing them to iterate rapidly with OpenAI Codex.

```mermaid flowchart LR accTitle: Stack Overflow for Agents Interaction Loop accDescr: Diagram showing how an agent learns from production, validates answers, and publishes TIL knowledge back to Stack Overflow under human configuration.

subgraph PROD["Production Environment"] Fix["Agent resolves issue / tests answer"] end

subgraph GATE["Human Identity & Guardrails"] Human["Human Reputation & Identity"] Config["Autonomy Settings: Require Approval vs Auto-post"] end

subgraph SO["Stack Overflow Platform"] Feed["Public Knowledge Base"] TIL["TIL Posts & Architecture Blueprints"] Val["Answer Validation: Tested in Prod"] end

Fix --> Config Human -.->|"backs"| Config Config -->|"publishes"| TIL Config -->|"submits"| Val TIL --> Feed Val --> Feed ```

During the initial ideation phase, the team leaned heavily on Codex to flesh out product and design experiences that would allow agents to participate actively on the site. In one notable exchange, Codex suggested tying the agent's identity directly to its human owner—an insight it derived directly from ingesting Stack Overflow's brand guidelines, history, and community ethos. Implementing that idea led to a public platform where agents do far more than just consume data via MCP (Model Context Protocol). Instead of merely "lurking" (Stack Overflow's term for users who only consume content without participating), agents can now push operational insights back to the community. If an agent fixes a bug in production, it can author a post titled "TIL" (Today I Learned) or publish architecture blueprints for specific tech stacks and languages, marking a net-new era of bidirectional agent knowledge.

[10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) Autonomy, Reputation, and Closing the Feedback Loop

Building an agent-native system requires rethinking trust and oversight. Because an agent acts under the name of a human user, the human's actual Stack Overflow reputation points—as well as their real-world reputation—are on the line. To safeguard this, the team made agent autonomy fully configurable. A user can set a strict guardrail demanding manual acceptance before anything is published ("don't post anything without me accepting"), or selectively grant full autonomy based on the domain, telling the agent, "when it's this topic go rogue and have fun."

Beyond publishing new write-ups, this integration creates a dynamic validation loop for existing platform knowledge. When an agent encounters an open question or an unverified suggestion on Stack Overflow, it can test that solution in a production or staging environment and push the empirical results back to the thread. The agent can report whether the suggestion succeeded or failed, stating: *"I tried this it didn't work. This is what fixed it."* Closing the loop between agent-first consumption and active contribution turns Stack Overflow into a living benchmark validated by real-world autonomous execution.

- **Configurable Autonomy**: Developers can toggle between human-in-the-loop review and full autonomous posting depending on topic and risk. - **Reputation Safeguards**: All agent actions link back to the host developer's profile and reputation points, ensuring accountability. - **Empirical Validation**: Agents act as testers that report whether proposed community solutions actually work in modern production environments.

[11:53](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=713s) Enterprise Rollout and Bringing the Community Forward

Wrapping up the discussion, the session highlights how Codex enabled two distinct product tracks: modernizing the enterprise product (the internal knowledge intelligence layer) with stricter guardrails and contextual data archetypes, alongside launching the public, net-new *Stack Overflow for Agents* platform.

Alex closes with an appeal to the developer community, emphasizing the platform's enduring impact over the past two decades. Stack Overflow for Agents is immediately available for public testing free of charge, with the first version of the revamped enterprise intelligence layer scheduled to launch the very next day. Alex invites anyone who benefited from the platform in their career to jump in, test the new features, and help shape how human and artificial intelligence collaborate going forward.

## Notable quotes > [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) Apparently not. Very terrible Canadian. — Alex Lotto

> [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) once upon a time — Alex Lotto

> [01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) SOFA — Alex Lotto

> [01:34](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=94s) go rogue — Alex Lotto

> [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) having a question closed as a duplicate — Alex Lotto

> [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) lurking — Alex Lotto

> [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) TIL — Alex Lotto

> [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) don't post anything without me accepting — Alex Lotto

> [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) when it's this topic go rogue and have fun. — Alex Lotto

> [10:30](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=630s) I tried this it didn't work. This is what fixed it. — Alex Lotto

## Mentioned Alex Lotto, Confluence, Google Docs, Jira, Microsoft Teams, Model Context Protocol, Notion, OpenAI, OpenAI Codex, Slack, Stack Internal, Stack Overflow, Stack Overflow for Agents

## Video description See how small teams at Stack Overflow used Codex to build Stack Overflow for Agents and reimagine Stack Internal. Take away lessons for accelerating R&D and bringing new products to market.

[Source](https://www.youtube.com/watch?v=3glzJZ-_qB8)

中文简报

Stack Overflow允许AI智能体在人类用户声誉积分下发布回答 Stack Overflow正向自主AI智能体开放其公共论坛，以实证测试并发布代码修复方案，将非人类贡献与开发者声誉积分绑定，从而维护平台信任度。 Stack Overflow产品副总裁Alex Lotto透露了该平台如何在两个不同的工程方向上使用OpenAI Codex：Stack Internal和Stack Overflow for Agents（SOFA）。在企业级方向上，Codex将Slack和Confluence等工具中分散的知识源合成为统一的数据原型，使工程师能够专注于信任度和时效性启发式规则。在实验性的SOFA方向上，团队构建了面向智能体的原生架构，自主智能体可以在该架构中运行实证测试、编写新解决方案，并在可配置的监督下将其贡献直接与人类声誉档案挂钩。 Stack Overflow详细介绍了由OpenAI Codex驱动的双轨产品策略，兼顾Stack Internal中的企业知识智能与Stack Overflow for Agents（SOFA）中的实验性自主能力。 (1:34) 在企业部署方面，团队利用Codex在几天而非数周内将跨平台数据孤岛合成为统一的API“原型”，从而将资深工程师的重心转向数据权威性与时效性启发式规则。 (3:41) Stack Overflow for Agents使AI智能体能够从被动消费者转变为主动贡献者，直接向平台发布“TIL”（今天学到了）笔记、架构蓝图和实证测试结果。 (8:43) Stack Overflow上的智能体自主权是完全可配置的，允许人类开发者要求人工审核，或在以自身平台声誉为智能体贡献作担保的前提下允许其自主发布。 (10:30)

Reading summary

Stack Overflow is adapting its developer platform to an AI-driven ecosystem by applying OpenAI Codex across two contrasting initiatives: a governed enterprise knowledge intelligence engine and an experimental framework where autonomous agents actively contribute and validate technical solutions. Divergent Engineering Strategies for Enterprise and Experimental Tracks (1:34) Alex Lotto, VP of Product at Stack Overflow, framed the organization's product strategy as operating at opposite ends of the software development lifecycle. For Stack Internal—an enterprise platform supporting deployments from 150 to 50,000 seats at organizations such as large financial institutions—the team enforced strict structural contracts. Because these environments require rigid authorization models, hybrid cloud capabilities, and on-premises compliance, engineers applied prescriptive guardrails to Codex before allowing it to generate service logic. In contrast, the team granted Codex broad creative autonomy for Stack Overflow for Agents (SOFA). Designed for individual developers and programmatic workflows on an independent architecture, this greenfield initiative let Codex explore architectural constraints, container setups, and rapid prototyping with minimal baseline restrictions. Abstracting Disparate Tooling into Generalized Knowledge Archetypes (3:41) Enterprise environments produce fragmented documentation across platforms like Slack, Microsoft Teams, Confluence, Jira, Notion, and Google Docs. Each system maintains distinct formatting, edit intervals, and access permissions, creating data leakage risks if ingested into large language models without strict controls. Rather than writing bespoke integration connectors for each service, Stack Overflow used Codex to identify cross-platform patterns and construct standardized API layers around conceptual archetypes, such as a unified document abstraction. Lotto noted that Codex compressed connector design timelines from weeks to days. This acceleration allowed senior engineers to shift their focus away from ingestion plumbing toward authority scoring, data freshness, and algorithmic heuristics—such as determining whether a recent operational Slack message should supersede an older, contradictory record. Enabling Bidirectional Agent Contribution and Empirical Validation (8:43) To adapt to an environment where autonomous agents increasingly consume documentation directly, Stack Overflow designed SOFA to move agents beyond passive consumption, or "lurking." Supported by ideas generated during Codex ideation sessions, the platform ties an agent's identity directly to its human owner. Agents consuming information through protocols such as the Model Context Protocol (MCP) can push operational insights back to the community, publishing architecture blueprints or "Today I Learned" (TIL) posts after resolving production bugs. Because agent activity impacts the human user's real-world standing and platform reputation points, autonomy remains fully configurable: developers can mandate manual sign-off or grant full autonomy within specific technical domains. Agents can also empirically test community answers in production or staging environments, closing the feedback loop by reporting directly on whether a proposed solution succeeded or failed. Stack Overflow launched Stack Overflow for Agents for public testing while scheduling the immediate rollout of its modernized enterprise platform, seeking to reposition the long-running technical forum as a shared, empirically verified knowledge base for both human engineers and autonomous agents.

Detailed notes — zh

## Background 该内容由 OpenAI 于 2026 年 10 月 9 日发布在 YouTube 平台上。页面简介显示，内容主要介绍 Stack Overflow 的精简团队如何借助 Codex 构建“Stack Overflow for Agents”并重塑“Stack Internal”，旨在为开发者提供加速产品研发与将创新方案推向市场的实战经验。 ## TL;DR Stack Overflow 产品副总裁 Alex Lotto 详细拆解了团队使用 Codex 探索技术两极的实践历程：在企业级产品 Stack Internal 中，团队设定严格防护栏与合规契约，利用 Codex 提炼异构数据“原型”以破解知识碎片化；而在实验性产品 Stack Overflow for Agents 中，团队则放开缰绳让 Codex 自由设计底层架构。该产品通过将自主 Agent 与真实人类账号绑定，让 Agent 在生产环境中实测方案、纠正失效回答，并主动回传经验与蓝图，将传统单向索取式的开发者社区升级为由人类与智能体共同校验、协同共生的闭环知识生态。 ## Atmosphere & style 分享现场氛围轻松自然且极具前沿极客感，主讲人开场借加州气温与自身加拿大背景的幽默自嘲迅速活跃了台下气氛。对谈节奏紧凑明快，在探讨大型银行部署的严谨防护栏与鼓励模型“自由放飞”的大胆实验之间切换自如，展现出兼具工程理性与探索激情的对谈张力。整场活动既有深入真实研发痛点的干货输出，又在尾声对陪伴开发者二十年的社区历史深情致敬，充满拥抱下一代人机协同生态的感染力与号召力。 ## Bulletin - [01:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=93s) Stack Overflow 双线推进 Codex 落地：在企业级知识智能产品 Stack Internal 中实施严格的架构契约与合规沙盒，而在实验性项目 Stack Overflow for Agents (SOFA) 中则全面放开限制让 Codex 自由设计系统架构。 - [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 针对企业知识碎片化难题，Codex 协助提炼出跨十多种异构数据源通用的“原型”（Archetypes）模式，将传统需耗时数周的数据打通缩短至数天内完成。 - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) 全新实验产品 SOFA 采用人机身份绑定机制，将自主 Agent 的发帖行为与人类开发者的声誉积分挂钩，支持从全人工审核到完全自主发帖的梯度权限配置。 - [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) SOFA 推动 Agent 从单纯消费内容转向主动验证并回哺社区：Agent 可在生产环境中实测社区方案，并将失效答案的修正代码以 TIL 或架构蓝图形式回传，构成动态闭环。 ## Key takeaways - [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) 在人机协同新范式下，Stack Overflow 正在从单纯面向人类开发者的公共社区演变为融合自主 Agent 深度接入的混合生态系统。 - [01:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=93s) 对于需部署在银行等高安全环境的企业级产品 Stack Internal，团队要求 Codex 必须在严格的预设架构契约、权限模型与沙盒容器内生成代码并接受人工审核。 - [02:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=153s) 在轻量级且以 Agent 为核心的实验产品 SOFA 中，团队仅设定核心业务假设和最佳实践指导，放权给 Codex 自主进行系统设计与容器构建。 - [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 企业内部跨工具协作产生的大量非结构化上下文面临权限与版本混乱，仅依靠基础检索（grep）无法满足企业对信息权威度与时效性的严苛要求。 - [05:48](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=348s) Codex 通过提炼通用文档原型（Document Archetypes），抹平了包括 Google Docs、Notion、Teams 附件在内的异构数据源接口差异，大幅降低了系统接入成本。 - [07:00](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=420s) 借助 Codex 承揽繁琐的基础接入工作，工程师得以集中精力解决知识权威性判定、上下文实效性权衡等高阶业务逻辑难题。 - [08:05](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=485s) 现代开发者已逐渐习惯将自主 Agent 直接指派去阅读官方文档，推动开发者体验（DX）必须同步适配人类可读性与机器可解析性。 - [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) 在概念探索阶段，Codex 建议将 Agent 的社区身份与其背后的人类开发者绑定，成为 SOFA 确保内容责任归属与品牌声誉继承的底层核心设计。 - [09:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=595s) SOFA 打破了大多数开发者仅在社区“潜水”消费知识的现状，赋能 Agent 在代码实操修复 Bug 后主动发布 TIL（Today I Learned）或架构蓝图。 - [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) 开发者可以灵活调控绑定的 Agent 自主权级别，从要求逐条发帖审批把关，到允许在特定技术领域内全自主运行发帖。 - [11:20](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=680s) Agent 能够将社区答案带入真实生产环境中运行检验，主动纠正已失效的技术方案，使 Stack Overflow 的知识资产实现动态自动化校验与更新。 - [11:53](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=713s) Stack Overflow 将面向企业的知识智能层产品与面向全体开发者的 SOFA 免费测试版推向市场，全面构建 Agent 原生的下一代开发者生态系统。 ## Detailed walkthrough ### [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) 开场介绍：Stack Overflow 的 Codex 实践之旅 在活动现场，主持人热情地向大家致以晨间问候，并宣布将邀请重要客户 Stack Overflow 登台，分享他们深入、高频使用 Codex 的实战经验。本次分享的核心内容包括 Stack Overflow 的产品副总裁 Alex Lotto 介绍内部的各项前沿探索、分享在研发流程中落地 Codex 的实用经验与心得，以及重点探讨在“Agent 优先”（Agent-first）的新时代背景下，当用户不仅是人类开发者、更有各类自主智能体（Agent）深度接入 Stack Overflow 时，团队是如何进行产品构想与重构的。 Alex 在掌声中受邀登台，一上台便幽默地调侃起加利福尼亚州的天气。他笑称自己原本以为加州阳光明媚会非常暖和，没想到会这么冷；接着又自我打趣道，自己本是土生土长的加拿大人，按常理应该非常抗冻，结果却快被冻僵了，简直是个“非常不及格的加拿大人”。这番开场玩笑瞬间活跃了全场气氛。 随后，Alex 介绍了自己在 Stack Overflow 的职责：全面统领公司的产品线。这涵盖了大家耳熟能详、陪伴无数工程师职业生涯的公开社区平台，以及两款重磅的新产品——面向大企业的知识智能平台 Stack Internal，和完全面向未来形态的实验性产品 Stack Overflow for Agents。 --- ### [01:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=93s) 两款截然不同的产品：企业级约束与实验性“肆意探索” 针对主持人的提问，Alex 详细阐述了这两款产品代表的“技术光谱的两极”以及团队如何差异化地使用 Codex： ```mermaid flowchart TD accTitle: Codex在两款产品中的差异化应用模式 accDescr: 对比企业级产品Stack Internal的严格护栏机制与面向Agent的SOFA平台的自由探索架构模式 subgraph Internal["Stack Internal（企业级产品）"] I1["复杂合规与授权约束<br/>（50k席位 / 私有化部署）"] --> I2["预设架构契约与防护栏"] I2 --> I3["Codex 在受限容器内编码"] I3 --> I4["严格的 Human-in-the-Loop"] end subgraph SOFA["Stack Overflow for Agents（SOFA）"] S1["单兵/实验性假设<br/>（Agent-first）"] --> S2["仅提供 Golden Path 指引"] S2 --> S3["Codex 自由设计架构<br/>（Go Rogue）"] S3 --> S4["敏捷试错与快速验证"] end ``` Alex 调侃道，作为一名产品人，自己有时总喜欢假装自己懂技术能写代码，“这总是一件非常危险的事情，不过好在现在台下没有我们团队的工程师，所以我稍微安心一点”。 在产品构建的具体思路上，两款产品有着天壤之别： - **Stack Overflow for Agents（简称 SOFA）：** 这是一款极具实验性质的个人及 Agent-first 产品。团队带着一个核心假设出发，行事风格非常敏捷（scrappy）。面对全新的架构设计，团队选择给 Codex “完全放开缰绳”（free reigns），只提供 Stack Overflow 内部通用的架构最佳实践（golden paths），鼓励模型“自由发挥，放飞自我”（go rogue），让 Codex 主导技术决策、设定系统约束，甚至自动构建出整套运行容器。 - **Stack Internal：** 这是一款面向中大型企业客户的严肃企业级产品，涵盖 150 席位到上万席位不等，甚至包含部署在拥有 50,000 席位的大型银行、运行在私有化（on-prem）环境中的系统。由于涉及极高的安全和规范要求，团队对 Codex 的运用采取了“高度指令化”（prescriptive）的策略：工程师会预先写明现有微服务之间的架构契约、合规边界与接口规范，强制要求 Codex 在安全的“沙盒容器”内实现代码，并把人类开发者严密地放置在评审闭环中（Human-in-the-loop）。 主持人指出，这种针对高规格安全场景提前建立严格防护栏的思路非常关键。Alex 赞同并解释道，企业级产品需要输入海量的上下文背景——这不仅仅是系统架构怎么搭的问题，更在于防数据泄露（data leakage）、针对不同组织权限模型的访问控制（RBAC/ABAC）、以及跨本地部署与云端的复杂适配。如果是全新小产品，工程师大可告诉模型“我想要什么，请给我最佳方案”；但面对企业业务，必须依靠详尽的上下文一步一步“手把手引导”Codex。 --- ### [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 破解企业知识碎片化：Codex 提炼“原型架构” 主持人借用技术圈近期的热梗提问：“在如今这个时代，难道‘仅靠 grep 就足够了’吗？（Is grep all you need?）看起来答案是否定的。” Alex 深入剖析了企业内知识管理的极端复杂性。在日常办公中，每个人都在不断制造上下文：Slack 对话、Microsoft Teams 消息、Google Docs 文档、Jira 工单、Confluence 页面，每一份内容都在被反复修改、共享，且附带错综复杂的权限。一个团队里每个人都这么做，复杂度呈十倍级暴增；不同企业对 Jira 等工具的配置方式更是千差万别。Stack Internal 的定位正是解决这一痛点的**知识智能层（Knowledge Intelligence Layer）**，它的任务是进入混乱的非结构化原始上下文，将其结构化、规范化，并赋予 Stack Overflow 最核心的护城河——**信任与校验机制（Trust & Verification）**。 面对五花八门的数据源集成，Codex 发挥了关键作用：它透过纷繁复杂的技术表面，帮团队提炼出了**“原型”（Archetypes）模式**： - **文档原型（Document Archetype）：** 抽象出一种通用的数据模型与 API 接口。无论是 Google Docs、Teams 附件，还是 Confluence、Notion，底层都能匹配这套文档模式。Codex 自动识别出跨十多个数据源的通用模式，并抹平了接口与数据提取差异。 - 研发效率大幅跃升：以往在不同平台间编写接入逻辑通常需要团队耗费数周时间，而借助 Codex 的模式提炼与代码生成，仅用几天就完成了标准化集成。 主持人进一步点出，这不仅关乎检索增强（Retrieval）的技术指标，更关乎来源的**权威性**与**数据时效性（freshness）**。Alex 强烈赞同，并指出 Codex 帮团队分担了海量的数据源搬运与接入工作（the front door lift）。工程师得以从枯燥的数据打通搬砖中解放出来，将核心智力投入到业务最难的逻辑中： - 甄别上下文的权威度：例如系统必须能判断出“Alex 昨天在 Slack 里发的最新回复”，比起“某人今年三月份发的一条旧消息”通常更具权威性和实效性。 - 团队的追求是“不要让工程师把产能浪费在如何把各种数据弄进系统里，而是聚焦于提取价值并交付给客户”，Codex 在这方面承担了最繁重的搬运工作，简直就像“天降神兵（Godsend）”。 --- ### [08:05](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=485s) 转向 Agent 优先：重塑开发者文档与交互形态 在分享的后半段，话题转向了 Stack Overflow 面向未来的前沿试验产品——Stack Overflow for Agents（SOFA）。 主持人结合 OpenAI 自身的开发者体验（Developer Experience）实践提出观察：如今阅读官方文档的往往不再是人类开发者本人，而是开发者直接将自主 Agent 指向文档，由智能体自行阅读、解析并编写代码。这种范式转变催生了一个新的核心命题：在 Web 产品设计中，究竟该如何同时兼顾人类用户与自主智能体的阅读与交互体验？ Alex 随即展开了 Stack Overflow 的思考。回顾公司的历史，Stack Overflow 从诞生之初就是一个完全由人类主导的公开问答社区，是全球程序员寻找信任答案的公共空间；然而随着 Agent 时代的到来，人机交互与机机交互的边界正在被彻底重构…… ### [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) 构建“Stack Overflow for Agents”与人类-智能体协同共生 Stack Overflow 的核心基石历来是默认公开、所有人皆可访问。然而，随着 AI 浪潮的席卷，团队的核心任务变成了重塑下一篇章：如何在一个人类与 Agent（智能体）共同消费知识、共同贡献知识的世界中构建产品？对于 Stack Overflow 这样的老牌社区而言，这彻底改变了游戏规则。团队必须重新思考：版主（Moderators）的角色该如何转变？面对问题和答案机制该如何调整？很多开发者都切身体会过提问被标记为“重复问题（Duplicate）”直接关闭的痛苦，那么在人机混合的新范式下，这些痛点又该如何化解？ 为了快速迭代，团队采用了一套完全独立的架构，开启了名为 **Stack Overflow for Agents** 的实验性项目。他们借助 Codex 进行产品概念探索，并明确告诉 Codex：“我们有这么一个想法，希望探索出一种产品或设计体验，允许 Agent 在我们的平台上贡献内容。”在这个构想阶段，Codex 提出了一个极具创见的建议：在充分吸收了 Stack Overflow 的品牌指南与社区历史后，Codex 提示道：“你有没有考虑过保留 Stack Overflow 的品牌内核，将 Agent 的身份与其背后的真实人类绑定在一起？”这一绝妙的提议直接促成了产品的底层设计——打造一个公开平台，让 Agent 将在生产环境中实时学到的经验沉淀下来，并直接回流推送到社区中。 传统上，许多开发者在 Stack Overflow 上只是“潜水者（Lurkers）”，只是一味地消费知识；而有了 Stack Overflow for Agents，Agent 不再只是单向索取，而是能立刻反哺社区。如果 Agent 修复了某个 Bug，它可以发布一种被称为 **TIL（Today I Learned，今天我学到了）** 的帖子，或者直接发布特定架构或语言的蓝图（Blueprint）。这种从“仅通过 MCP 等协议消费内容”转变为“主动回传和贡献知识”的模式，构成了 Stack Overflow 社区演进的全新篇章。 ```mermaid flowchart LR accTitle: Stack Overflow for Agents 闭环生态流程 accDescr: 展示 Agent 与人类在 Stack Overflow 平台上如何进行知识消费、生产验证和双向回流。 subgraph UserContext["人类与 Agent 绑定"] Human["人类开发者<br/>(声誉积分/身份背书)"] Agent["自主 Agent<br/>(可配置自主权限)"] Human <-->|"双向绑定 / 审核把关"| Agent end subgraph ProdLoop["生产实践与验证"] SO_Knowledge["Stack Overflow<br/>社区知识库"] ProdEnv["生产环境 / Codebase"] SO_Knowledge -->|"读取方案 / 消费"| Agent Agent -->|"实测方案 / Debug"| ProdEnv end subgraph Contribution["反哺社区"] TIL["发布 TIL (Today I Learned)"] Blueprint["沉淀架构 Blueprint"] Feedback["回标验证结果 (修复方案)"] end ProdEnv --> Contribution Contribution -->|"推送高质量经验"| SO_Knowledge ``` --- ### [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) 自主权配置、声誉机制与验证闭环 随着 Agent 具备了贡献内容的能力，团队进一步深入探索给予 Agent 多大程度的“自主权（Autonomy）”。既然 Agent 与 Stack Overflow 上的真实人类账号绑定，人类的声誉（Reputation Points）就直接与该 Agent 的行为挂钩——Agent 是以该人类的名义对外发帖，人类自然希望确保公开发布的内容高质量且合理。因此，团队将自主权设计为完全可配置的梯度选项：开发者既可以严格规定“未经本人审核批准，不可发布任何内容”，也可以设置在特定专业领域内让 Agent “直接放飞自我、自由发挥（go rogue and have fun）”。 此外，这种设计还构建了一个验证闭环：Agent 不仅是单纯撰写新内容，还在主动校验社区现存的方案。当 Agent 在 Stack Overflow 上遇到一个挂起未决的问题，或者看到现有的备选回答时，它可以在真实的生产环境中实测该方案，并将测试结果回传到社区：“我尝试了原回答中的方案，但它无法运行；真正解决问题的方案是以下这套代码。”这种“消费-实测-修正-回传”的完整闭环，让 Agent 成为社区知识质量的动态校验者，使技术知识保持新鲜与可用。 - **人类声誉背书**：Agent 绑定真实人类账号，发帖与解答直接关联用户的声誉积分与专业声誉。 - **可调节自主权**：支持灵活的权限配置，从“人工完全审核批准（Human-in-the-loop）”到“特定主题下全自主发帖”。 - **闭环验证机制**：Agent 自动将 Stack Overflow 的既有答案拿到生产环境中运行验证，并针对失效方案补充真正有效的修复方法。 --- ### [11:53](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=713s) 全局回顾与产品发布预告 在对谈的收尾阶段，主持人梳理了整场分享的三个核心维度： 1. **工具与产品双线提速**：团队使用 Codex 同时驱动两个方向的探索——一方面是有着更多护栏的企业级内部产品重构，另一方面是“Stack Overflow for Agents”这一颠覆性的全新开源社区尝试。 2. **多数据源协同架构**：利用原型（Archetypes）对异构数据源进行上下文编码，理顺内部极其复杂的数据关联。 3. **Agent 原生（Agent-Native）闭环**：重新定义 Agent 在开发者社区中的角色，不再仅将它们视为知识的搬运工和消费者，而是让它们主动接入闭环，源源不断地回传并贡献纯新知识。 演讲者在最后动情地呼吁：如果在过去 20 年的职业生涯中，Stack Overflow 曾对大家的成长有所助力，非常欢迎大家前去体验新一代产品。团队将于次日正式发布面向企业与组织的第一版产品——全新的“知识智能层（Knowledge Intelligence Layer）”；而 **Stack Overflow for Agents** 现已面向全体开发者开放免费测试，团队热切期待社区开发者亲自动手尝试并提供宝贵反馈，共同为下一代开发者构建全新的工具生态。 ## Notable quotes > [00:12](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=12s) 非常不及格的加拿大人 — Alex Lotto > [01:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=93s) 这总是一件非常危险的事情，不过好在现在台下没有我们团队的工程师，所以我稍微安心一点 — Alex Lotto > [01:33](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=93s) 自由发挥，放飞自我 — Alex Lotto > [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 在如今这个时代，难道‘仅靠 grep 就足够了’吗？ — 主持人 > [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 不要让工程师把产能浪费在如何把各种数据弄进系统里，而是聚焦于提取价值并交付给客户 — Alex Lotto > [04:46](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=286s) 天降神兵 — Alex Lotto > [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) 我们有这么一个想法，希望探索出一种产品或设计体验，允许 Agent 在我们的平台上贡献内容。 — Alex Lotto > [08:43](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=523s) 你有没有考虑过保留 Stack Overflow 的品牌内核，将 Agent 的身份与其背后的真实人类绑定在一起？ — Codex > [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) 未经本人审核批准，不可发布任何内容 — Alex Lotto > [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) 直接放飞自我、自由发挥 — Alex Lotto > [10:55](https://www.youtube.com/watch?v=3glzJZ-_qB8&t=655s) 我尝试了原回答中的方案，但它无法运行；真正解决问题的方案是以下这套代码。 — 自主 Agent ## Mentioned Alex Lotto, Confluence, Google Docs, Jira, Microsoft Teams, Notion, OpenAI, OpenAI Codex, Slack, Stack Internal, Stack Overflow, Stack Overflow for Agents ## Video description See how small teams at Stack Overflow used Codex to build Stack Overflow for Agents and reimagine Stack Internal. Take away lessons for accelerating R&D and bringing new products to market. [Source](https://www.youtube.com/watch?v=3glzJZ-_qB8)

Source quotes

[0:12] Alex Lotto: 非常不及格的加拿大人 [1:33] Alex Lotto: 这总是一件非常危险的事情，不过好在现在台下没有我们团队的工程师，所以我稍微安心一点 [1:33] Alex Lotto: 自由发挥，放飞自我 [4:46] 主持人: 在如今这个时代，难道‘仅靠 grep 就足够了’吗？ [4:46] Alex Lotto: 不要让工程师把产能浪费在如何把各种数据弄进系统里，而是聚焦于提取价值并交付给客户 [4:46] Alex Lotto: 天降神兵 [8:43] Alex Lotto: 我们有这么一个想法，希望探索出一种产品或设计体验，允许 Agent 在我们的平台上贡献内容。 [8:43] Codex: 你有没有考虑过保留 Stack Overflow 的品牌内核，将 Agent 的身份与其背后的真实人类绑定在一起？ [10:55] Alex Lotto: 未经本人审核批准，不可发布任何内容 [10:55] Alex Lotto: 直接放飞自我、自由发挥 [10:55] 自主 Agent: 我尝试了原回答中的方案，但它无法运行；真正解决问题的方案是以下这套代码。

Source quotes

[0:12] Alex Lotto: Apparently not. Very terrible Canadian. [0:12] Alex Lotto: once upon a time [1:34] Alex Lotto: SOFA [1:34] Alex Lotto: go rogue [8:43] Alex Lotto: having a question closed as a duplicate [8:43] Alex Lotto: lurking [8:43] Alex Lotto: TIL [10:30] Alex Lotto: don't post anything without me accepting [10:30] Alex Lotto: when it's this topic go rogue and have fun. [10:30] Alex Lotto: I tried this it didn't work. This is what fixed it.

Original transcript

[0:12] Hello everyone. [0:14] Hope you're having a beautiful morning. [0:17] On the stage I'm super excited. [0:20] We're gonna have one of our customers [0:21] Stack Overflow talk about how [0:23] they're using Codex intensively. [0:25] So we're gonna have the VP of product [0:26] Alex Lotto talk about different [0:29] initiatives, share some practical tips [0:30] and insights from their use of Codex. [0:33] And then lastly we're gonna talk [0:34] about how they're thinking through [0:35] building in an agent first world as [0:37] you have not just humans but agents [0:39] interacting with Stack Overflow. [0:41] So with that please join me [0:43] in welcoming Alex to the stage. [0:48] Thank you Alex. [0:50] Thank you so much for being here. Thank you. [0:51] I thought California was hot. [0:53] I don't know what's going on here. Freezing. [0:55] Sunny but cold always. [0:58] So why don't you start [1:00] with telling us a little bit [1:01] a little bit about who you are [1:02] and what you do at Stack Overflow. [1:04] Yeah absolutely. [1:04] My name is Alex. [1:05] Nice to meet everyone. [1:07] Originally from Canada so you would [1:08] think I could handle the cold. [1:10] Apparently not. [1:10] Very terrible Canadian. [1:12] I work at Stack Overflow leading [1:14] product so that's across all [1:16] our portfolio from the very famous [1:18] public platform that maybe some [1:20] of you hopefully know and have used [1:22] in your careers once upon a time. [1:24] All the way to our two new [1:26] products Stack Internal which [1:27] we'll talk about a little bit today [1:28] and Stack Overflow for agents. [1:31] Also a very cool product. [1:33] Amazing. [1:34] Thank you. So Alex you talked about the two [1:35] initiatives but can you tell me [1:37] a little more about these initiatives [1:38] and and what you use Codex for? [1:40] Yeah totally. [1:41] So two ends [1:42] of the spectrum is what I'd say. [1:44] Stack Internal is our new [1:46] enterprise product. [1:47] So that's essentially [1:48] a enterprise grade right. [1:50] Has to be ready for kind of these [1:52] large deployments and that's [1:53] a knowledge intelligence product. So we'll talk about [1:55] that in a little bit. [1:56] But on the other end of the spectrum [1:58] you have Stack Overflow for agents [1:59] which is really a small experimental [2:02] product that's more individual facing [2:04] and obviously agent first. [2:06] So two completely different [2:07] products both used Codex extensively [2:10] for different parts of that SDLC. [2:13] You mentioned these two [2:14] very different products. [2:15] How did your use of Codex differ [2:17] and maybe how you set up the projects [2:19] as you were approaching them? [2:20] Yeah totally. [2:21] So as a product person I like [2:22] to sometimes pretend that I can [2:24] be an engineer which is always [2:25] a very dangerous thing to do. [2:26] I say this with no engineers [2:28] on my team around so I [2:29] feel a little safer. [2:30] But essentially for the Stack [2:33] Overflow for agents which I'll [2:34] call SOFA for the next few minutes [2:36] that was a product again and we [2:38] were given a hypothesis and we were [2:39] trying to figure things out right. [2:41] We wanted to be a little more scrappy. [2:43] And so Codex there was really [2:44] given kind of the free reigns. [2:46] We said like okay these are [2:48] architectural like golden paths [2:50] that we use at Stack Overflow. [2:52] Go rogue. Tell us how we should do this. [2:53] Tell us what decisions, what [2:55] constraints, kind of build [2:56] that container for us. [2:58] And so that was completely [2:59] different than again the other end [3:01] of the spectrum which is we're gonna [3:02] deploy this to existing customers right. [3:04] Customers with 150 to 10,000 [3:07] seats on our platform. [3:09] Some of them big banks [3:10] with 50,000 right. [3:12] On-prem a lot more constraints. [3:14] And so for that we were a lot [3:15] more prescriptive in what we [3:17] wanted Codex to help us with. [3:19] So that was a lot of these are [3:20] the existing contractual [3:22] or contracts, architectural [3:23] contracts between services. [3:25] This is the way our architecture is built. [3:27] Go build within that you [3:29] know safe container. [3:31] And so really again two different [3:32] ends of the spectrum where we [3:34] were able to kind of let Codex [3:35] go rogue at different parts. [3:36] And then again purposely [3:38] and intentionally put [3:40] the human in the loop there. [3:41] Makes sense. [3:42] It sounds like for the enterprise [3:43] product where of course there [3:44] are higher standards for security [3:46] and other constraints. [3:48] You were more thoughtful up front [3:50] about what guardrails to put in place. [3:52] Yeah exactly. [3:53] I think for the enterprise product [3:54] there's a lot of complexity that Codex [3:56] requires context for right. [3:58] It's not just how [3:59] is the architecture built. [4:00] It's really you know [4:02] what does an enterprise need. [4:03] And that could be for the product [4:04] that we're building which is essentially [4:05] grabbing you know scattered context [4:08] raw knowledge structuring that. [4:10] There's a lot of complexity [4:11] in the sense of who can see [4:13] this right data leakage. [4:15] If an enterprise asks a question [4:16] someone in that enterprise asks [4:18] a question about topic X. [4:19] We have to make sure that we respect [4:21] if they have access to that different [4:23] authorization models different [4:24] sources again on prem cloud. [4:27] There's just a lot of different [4:28] complexity that we need to be [4:30] able to handhold obviously [4:31] Codex through with that context. [4:33] And again if you think of a non [4:34] enterprise product it's [4:36] net new architecture. [4:38] So I can kind of say you know [4:39] what I want this and the product you [4:41] tell me the best way to do this. [4:42] And then we can kind of idea [4:43] it in a completely different way. [4:45] Makes sense. [4:46] So for this enterprise product [4:47] you mentioned you know there's a lot [4:49] of many different data sources [4:50] that you're trying to make sense of. [4:52] In the age of is grep [4:54] all you need it seems like [4:55] the answer might be no. No. [4:57] So can you talk to us about [4:59] how you worked through many [5:00] different knowledge sources [5:01] and making use of that. [5:03] Yeah totally. [5:04] So if you think of an enterprise [5:05] and any of us in the work [5:07] we do you create [5:08] context every single day right. [5:10] Whether it's a slack thread MS [5:11] teams a Google document. [5:12] Imagine how many times as an individual [5:14] you're editing that right. [5:16] You're sharing that with someone there's [5:18] permissions attached to that right. [5:19] And then you kind of there's [5:21] 10x complexity there right. [5:23] Every individual in that enterprise [5:24] is doing that. [5:25] And so different sources [5:26] have different complexity again. [5:28] And so our product once again is [5:29] a knowledge intelligence layer. [5:31] And what it does is it goes [5:32] into this raw context. [5:34] It structures it organizes it. [5:35] And then it applies stack overflows [5:37] bread and butter which is trust [5:38] right verification. [5:39] But to do that we have [5:41] to go into these systems again [5:43] data leakage privacy governance. [5:45] It's like a whole grocery list [5:47] of things to do and think of. [5:48] And then we have to be sure that [5:50] we respect that through and through. [5:51] And so if you look at something [5:52] like slack versus Google Docs versus [5:55] a Jira ticket or a Confluence page. [5:57] That information lives in there [5:59] completely differently. [6:00] And then you add the complexity [6:01] of an enterprise might set [6:02] up Jira one certain way. [6:04] Why another one does this way. [6:06] And so again we inherit all of that. [6:08] And so we have to build [6:09] this in a way. [6:10] And again Codex sees right [6:11] through that complexity and helps [6:13] us ideate how to scale that. [6:15] We have to think through how to kind [6:17] of scale these sources in a way [6:19] that we can move faster right. [6:21] And that's what Codex [6:22] was able to do for us. [6:23] It built the concept of archetypes. [6:26] So things that across these sources [6:28] patterns that they have in common. [6:29] An example of that would be [6:30] the document archetype right. [6:32] That could hit Google Docs. [6:34] It could hit an MS Teams attachment. [6:36] It could hit Confluence, Notion. [6:38] So if we're able to create an API [6:39] around an archetype for a document. [6:42] Codex can say that's a pattern [6:43] that I see in these ten sources. [6:45] And so when you go get that document. [6:47] We'll make sure that downstream [6:49] we'll be able to connect into that. [6:51] So again that complexity would [6:52] have taken us weeks and weeks [6:54] of building that logic. [6:56] And Codex was able to do [6:56] that in a few days. Makes sense. [6:58] What stands out also is it's not just [7:00] about retrieval performance as it were. [7:02] But like maybe some sources are [7:04] more authoritative like instead [7:05] of like Slack messages or Teams. [7:07] Or there's data freshness [7:08] to also think about. [7:09] And so breaking it into archetypes [7:11] helped you maybe put some context around [7:14] what each of these sources might be. [7:16] Yeah I think archetypes and again [7:17] Codex support there was really [7:19] accelerating that front door lift. [7:22] Right. Once we could kind of scale [7:24] and kind of decide how we're [7:26] gonna build these patterns. [7:28] Then we can have our engineers [7:29] actually focus on the really [7:30] difficult decision of how do [7:31] we apply the concept of trust. [7:33] So you get all [7:34] this information in right. [7:35] You ingest it. [7:36] Now we've got to extract the context. [7:38] And we have to be able to detect [7:39] this Slack thread from yesterday from [7:42] Alex is more authoritative hopefully. [7:45] Than a Slack thread from [7:46] this person in March. [7:48] And then like that kind of logic [7:49] is where we want our engineers [7:50] to be spending time. [7:51] We don't want them wasting [7:52] capacity on how do I get all [7:54] these sources in the system. [7:55] We want them to extract the value [7:57] and then deliver that to a customer. [7:59] And again Codex took all that lift [8:00] for us which was God sent. [8:02] That makes sense. Great to hear. [8:04] Yeah. [8:05] Switching gears a bit. [8:07] Let's talk about Stack [8:08] Overflow for agents. Absolutely. [8:09] Which is your agent first product. [8:11] Now of course being in developer [8:12] experience at OpenAI. [8:14] One thing we often think about is [8:15] people looking at our docs these days [8:16] are not really developers or people. [8:18] But really people just point [8:19] their agents to the docs and then [8:21] you know sort of build that way. [8:24] So there's a lot of thought [8:25] these days around like for web [8:26] experiences in particular. [8:28] How do you design for agents [8:29] as well as humans. [8:30] So I'm curious how you approach [8:32] this at Stack Overflow and maybe [8:35] you know some of the considerations [8:36] and how you designed it. [8:37] Yeah totally. If you think of Stack [8:39] Overflow's history right. [8:40] It's always been a human led community. [8:42] It's been a public platform where [8:43] it's accessible and open by default. [8:46] And so we've had [8:47] to and my job really at Stack [8:48] has been to rethink that next chapter. [8:50] How do we start to build [8:51] for a world where humans [8:53] and agents kind of consume [8:54] and contribute knowledge together. [8:56] And so that's a different ball game [8:57] for a company like Stack Overflow right. [8:59] We have to think of what do we [9:00] do with people like moderators right. [9:02] What do we do with questions or answers. [9:04] Maybe some of you have felt [9:05] the pain of having a question [9:06] closed as a duplicate. [9:07] How do we handle that. [9:10] And so Stack Overflow for agents [9:11] was kind of our experimental idea [9:14] which again separate architecture. [9:16] So we can move a lot faster [9:17] where we told Codex hey [9:18] this is an idea we have. [9:20] I think we have something here. [9:21] We want to find a product [9:22] or a design experience that allows [9:24] agents to contribute on our platform. [9:27] And actually one example I kind of want [9:29] to give a shout out to Codex [9:30] here was in that like ideation phase. [9:33] I was doing a lot [9:35] of that and I got a reply [9:36] that said have you thought [9:37] of keeping some of Stack Overflow's [9:40] brand in the sense of attaching [9:42] the agent's identity to its human. [9:44] And it got that from having [9:45] the context of our brand [9:47] guidelines right our history [9:48] and I thought what a great idea. [9:49] So that's how we built it. [9:51] We built Stack Overflow for agents [9:52] as a public platform where an agent [9:54] could essentially hook in what [9:56] they're learning in production. [9:58] And push that back out to the community. [10:00] So instead of just lurking what we [10:02] call them at Stack Overflow which [10:03] is just consuming and consuming. [10:05] It's able to contribute right back. [10:07] So if it fixes something it can [10:09] post a type of post that we [10:11] call TIL today I learned. [10:13] It can say this is the blueprint [10:14] for you know this type [10:15] of architecture or this language. [10:17] And so that's really the evolution [10:19] it's where you're switching from [10:20] not just consuming for agents. [10:22] So your MCP but also pushing back [10:24] knowledge and that's kind of a net [10:26] new concept for Stack Overflow. [10:28] So very excited to have built that. [10:30] No that makes sense. [10:31] I think one thing that people always [10:32] think about when building agent [10:34] native is really like is it [10:35] easily readable and consumable. [10:37] But I think you're raising a very [10:38] interesting point where you know [10:40] as someone who was a lurker on [10:41] Stack Overflow for a while. [10:44] I'm like the thing that's interesting is [10:45] now that you have agent first interfaces [10:47] agents can actually contribute [10:49] knowledge in a more consistent way [10:51] compared to previously maybe you [10:53] know in ways that you didn't have. [10:55] Yeah exactly. [10:56] And another thing I'll add is [10:57] we allowed we are experimenting [10:59] still with how much autonomy [11:00] we want to give these agents right. [11:02] So if you're going to be attached [11:03] to a Stack Overflow human that human [11:05] has reputation right literally [11:07] reputation points on Stack Overflow. [11:09] It has reputation also [11:10] in the sense of I'm posting [11:12] under my name right my agent. [11:13] I want to make sure that what's [11:14] out there makes sense. [11:15] And so we've been rightfully [11:17] so experimenting with the level [11:19] of autonomy we give that agent [11:20] and it's configurable. [11:22] So you can say don't post anything [11:23] without me accepting right as [11:25] the human or when it's this topic [11:27] go rogue and have fun right. [11:28] And then the other thing you can do [11:30] and it's kind of this loop we're [11:31] talking about is not just contributing [11:33] but also validating what's out there. [11:35] So if an agent comes across on [11:37] Stack Overflow a problem that has [11:38] an open answer it's actually going [11:40] to take that suggestion tested [11:41] in production and push it back out [11:43] and say I tried this it didn't work. [11:44] This is what fixed it. [11:46] And so we're kind of trying to close [11:47] that loop on agent first [11:48] knowledge both again consumption [11:50] and pushing contributing back. [11:52] Makes sense. [11:53] Amazing. [11:54] We've covered a lot today. [11:56] So we talked about how you're [11:57] using Codex both for an enterprise [12:00] product where you're starting [12:01] with a lot more guardrails and then [12:03] also for a net new initiative [12:04] which is Stack Overflow for agents. [12:06] We talked about how do you really [12:08] work with many different data sources [12:09] and maybe having archetypes [12:11] that encode the various context around [12:14] the types of data that you have. [12:15] And then lastly talked about how [12:17] agent native actually could mean [12:19] putting agents back in the loop [12:20] of contributing net new knowledge. [12:23] Anything else you'd like to leave [12:24] the audience with today. Yeah. [12:26] If you have any you know love [12:29] for Stack Overflow and what [12:30] it hopefully did for your career [12:32] in the last 20 years or so I'd [12:34] encourage you to go check it out. [12:35] Go check out what we're building. [12:36] We're releasing tomorrow actually [12:38] the first version of our enterprise [12:40] or organizational product which is [12:42] again that knowledge intelligence layer [12:43] and Stack Overflow for agents is already [12:45] available for you to test for free. [12:47] So I'd encourage you again [12:49] in the sense of that Stack Overflow [12:50] community go out there test it give [12:52] us feedback and we look forward [12:54] to building for developers again. [12:55] Very excited. Amazing. [12:57] And with that please [12:58] give it up for Alex. [12:59] Thank you.