OpenAI Engineer Urges Read-First Rollout for Enterprise AI Agents
Ai4
Enterprises must implement a read-first strategy before granting autonomous execution rights, enabling proactive AI agents embedded in shared workspaces to safely triage incidents and resolve tickets under human oversight.
## Background
Published on YouTube by the Ai4 channel on August 17, 2026, this presentation features Dikshit Khandelwal, Member of Technical Staff in Platform and Security at OpenAI. The session outlines practical architectural patterns and orchestration strategies for designing autonomous enterprise AI agents that integrate across workplace tools, handle failures, and execute complex workflows with human oversight.
## TL;DR
Khandelwal outlines the evolutionary shift from reactive chatbot prompts to proactive, autonomous AI agents embedded directly within team workspaces like Slack, Jira, and Linear. Using practical examples such as automated 3:00 AM on-call incident triage and internal IT service requests, he illustrates how agents can ingest alerts, analyze codebases, and draft pull requests in seconds. The architecture relies on institutional runbooks, structured agent playbooks with clear operational guardrails, and human-in-the-loop approvals. To safely introduce automation into enterprise infrastructure, he advocates for a phased 'read-first' rollout that validates model performance before granting scoped write permissions.
## Atmosphere & style
The presentation carries a pragmatic, technical, and grounded tone delivered with the authentic ease of an infrastructure engineer dogfooding agentic tools in his daily OpenAI workflows. By anchoring the discussion in universally dreaded developer experiences—such as groggy 3:00 AM on-call pages and overflowing ticket backlogs—Khandelwal establishes an empathetic, relatable connection with the audience. The talk blends forward-looking excitement over multi-fold productivity gains with a disciplined, risk-conscious emphasis on security boundaries and incremental rollout strategies.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=4s) Enterprise automation is evolving beyond reactive, prompt-driven chatbots toward autonomous agents capable of coordinating end-to-end workflows across diverse systems.
- [03:10](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=190s) Enterprises should pivot from reactive AI setups to proactive agents that continuously monitor systems, detect anomalies, and take initiative without waiting for human prompts.
- [03:10](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=190s) In on-call incident response, proactive agents can isolate root causes from logs and draft ready-to-merge pull requests within seconds of an alert being triggered.
- [06:11](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=371s) AI agents deliver the most value when embedded directly into existing collaborative platforms like Slack, Jira, and Linear rather than siloed inside standalone portals.
- [06:11](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=371s) An effective enterprise agent runtime relies on an institutional knowledge base—including SOPs and operational runbooks—to ground planning and tool execution within company policies.
- [10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) Deploying agents safely requires structured playbooks that explicitly define the agent's identity, allowed capabilities, scoped tool access, and hard operational boundaries.
- [10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) High-volume IT operations, such as security exception approvals and permission provisioning, can be handled autonomously or escalated with pre-gathered context according to policy.
- [12:34](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=754s) Background triage agents can process incoming support queries and service alerts in real time, dramatically reducing cognitive fatigue and preventing operational bottlenecks.
- [12:34](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=754s) Software development lifecycles can be accelerated by using agents to ingest bug reports or feature requests and autonomously produce initial code modifications as draft pull requests.
- [17:31](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=1051s) Organizations should adopt a staged rollout starting with a 'read-first' strategy, where the agent is limited to observing data, diagnosing issues, and proposing actions without write permissions.
- [17:31](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=1051s) Execution and write permissions should only be granted incrementally after human operators validate the agent's accuracy and operational reliability under supervision.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=4s) From Scripting to Agents: The Shift in Enterprise Automation
Dikshit Khandelwal—who goes by DK—works on internal infrastructure, platform development, and internal device management at OpenAI. Opening his session, he explains that his central mission across enterprise operations is finding ways to drastically elevate productivity through automation. He notes that the framework he is presenting is not just an abstract enterprise strategy, but a practical blueprint anyone can apply in their daily professional life. In fact, he jokes that he practiced what he preaches by using agentic automation to build and polish the very presentation slides he is delivering.
Tracing the evolution of modern computing, Khandelwal reminds the audience of the arc from bare-metal programming to contemporary AI. Decades ago, developers started in assembly language before advancing to compiled C and interpreted languages like Python. A few years ago, the ecosystem shifted dramatically with the advent of ChatGPT and prompt-driven interfaces, where users ask questions and get instant, useful answers. However, technology has now entered the "agentic" era. An agent is fundamentally different from a standard conversational chatbot. Rather than merely fetching an answer or returning a block of code upon command, an agentic system is designed to execute end-to-end workflows across diverse systems—analogous to autonomously coordinating an entire dinner rather than merely retrieving a recipe.
- **Speaker Role:** Dikshit Khandelwal (DK), Platform & Security / Internal Infrastructure at OpenAI.
- **Technology Arc:** Assembly language $\to$ C $\to$ Python $\to$ Prompted Chatbots (ChatGPT) $\to$ Autonomous Agentic Workflows.
- **Core Philosophy:** Moving past reactive Q&A toward autonomous task execution across enterprise tools.
---
[03:10](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=190s) The Proactive Agent: Redefining the 3:00 AM On-Call Incident
The traditional posture toward AI in enterprise settings has been fundamentally reactive: a customer or an employee faces an issue, prompts a chatbot, copies the output, and pastes it into an external tool. Khandelwal argues that organizations need to flip this paradigm on its head into a proactive stance. Instead of waiting for a human to instruct the model step-by-step—asking it to write a specific script or diagnose a known bug—a proactive agent continuously observes the operating environment, understands contextual background, recognizes when a request or an anomaly lands, and takes initiative.
To demonstrate the power of proactive workflows, Khandelwal points to the universal dread of engineering on-call rotations. Typically, an engineer is paged by an alerting system at 3:00 AM, stumbles out of bed, opens their laptop, and spends grueling minutes or hours sifting through thousands of log lines trying to deduce what broke. In a proactive agentic setup, the incoming alert immediately triggers an automated agent. Long before the engineer even opens their laptop lid—within 15 to 20 seconds—the agent has parsed the logs, traced the root cause, reviewed the affected codebase, and prepared a pull request with a complete summary and proposed fix. All that remains for the human is to provide a final review and click approve to ship the patch to production.
```mermaid
flowchart LR
accTitle: Incident Response Workflow Comparison
subgraph Reactive["Reactive Approach"]
direction TB
R1["3:00 AM Incident Page"] --> R2["Engineer Wakes & Logs In"]
R2 --> R3["Manual Log Sifting"]
R3 --> R4["Manual Root Cause Analysis"]
R4 --> R5["Draft Code Fix"]
end
subgraph Proactive["Proactive Agentic Approach"]
direction TB
P1["3:00 AM Incident Page"] --> P2["Agent Ingests Alert & Logs"]
P2 --> P3["Root Cause Isolated"]
P3 --> P4["PR & Summary Generated"]
P4 --> P5["Human Approves & Ships"]
end
```
---
[06:11](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=371s) The Architecture of a Shared Human-AI Workspace
Moving beyond single-user conversational plugins requires inviting AI agents directly into the shared workspaces where teams already collaborate. Rather than forcing employees to switch contexts to interact with an AI interface, the agent joins platforms like Slack, Jira, or Linear as an active teammate. By living inside the communication channels and project boards where work originates, the agent observes ticket creations, customer requests, and team discussions in real time, executing the necessary background investigation and updating work objects dynamically.
Khandelwal outlines the high-level architecture that enables this collaborative loop. It begins with incoming requests captured as work objects inside the shared environment. From there, the agent accesses an institutional knowledge base—consisting of internal documentation, standard operating procedures (SOPs), and operational guidelines—to ground its actions in organizational standards. Armed with contextual awareness and predefined tool permissions, the agent runtime initiates a loop of planning, executing, verifying, and learning. If a task requires human intervention or policy enforcement, the agent pauses the ticket, changes its status to awaiting review, and accepts human feedback directly within the shared thread.
```mermaid
flowchart TD
accTitle: Shared Human-AI Workspace Architecture
subgraph Collaboration["Shared Collaborative Surface"]
A["Workspace Triggers: Slack, Jira, Linear"]
end
subgraph CoreRuntime["Agent Runtime Engine"]
B["Work Object Ingestion"]
C["Planning & Context Synthesis"]
D["Execution & Tool Interaction"]
E["Outcome Verification & Retries"]
B --> C --> D --> E
end
subgraph Guardrails["Governance & Context"]
KB["Knowledge Base: SOPs & Internal Docs"]
Tools["Scoped Tools & Enterprise APIs"]
Human["Human-in-the-Loop Review"]
end
A --> B
KB --> C
Tools --> D
E --> Human
Human -- "Approved / Feedback" --> A
```
- **Collaborative Embedding:** Integrating agents directly inside Slack channels, Jira boards, and Linear projects rather than isolated portals.
- **Knowledge Base Layer:** Incorporating runbooks, standard operating procedures (SOPs), and architectural documentation to constrain actions to approved procedures.
- **Execution Loop:** Work object ingestion $\to$ context planning $\to$ tool interaction $\to$ verification $\to$ human sign-off.
---
[10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) Implementing Guardrails: Playbooks, Personas, and IT Requests
Khandelwal draws an analogy between configuring an autonomous agent and "nurturing a baby." An agent cannot simply be turned loose inside an enterprise infrastructure without a rigorously defined identity, explicit operational skills, and clear guardrails. At OpenAI, this is achieved through structured agent playbooks. A playbook establishes the agent's identity ("who am I?"), defines its explicit duties ("what can I do?"), catalogs the external microservices and tools it is allowed to interact with, and establishes strict boundaries around what actions it must never attempt autonomously.
He illustrates this with internal IT service desks, which regularly receive high volumes of repetitive inquiries regarding malfunctioning hardware, missing software permissions, active directory or group memberships, and security exceptions. Under an agentic model, an agent sits in the intake Slack channel, parses incoming requests, cross-references security guidelines and approval chains, and determines whether an exception can be safely granted. If the security criteria are fulfilled, the agent interacts with back-end enterprise services to apply the permission change autonomously; if policy requires escalation, it gathers context and routes the ticket to human security administrators with all necessary background details attached.
- **Playbook Fundamentals:**
- *Identity:* Explicit definition of the agent's persona and purpose.
- *Capabilities & Skills:* Catalog of specific tasks the agent is trained to execute.
- *Tool & Service Access:* Scoped integrations with internal APIs and administrative tools.
- *Boundaries & Guardrails:* Explicit constraints on unauthorized data access or sensitive operations.
- **Practical IT Use Cases:** Managing security exception approvals, assigning group access permissions, and diagnosing broken workplace hardware.
---
[12:34](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=754s) Autonomous Incident Triage and the Software Lifecycle Loop
Returning to developer workflows, Khandelwal describes his own setup within OpenAI's Codex ecosystem. As an infrastructure engineer, he regularly encounters internal support pings, review requests, and service pages. Rather than letting unread notifications accumulate, he runs continuous background agent workflows. When an alert arrives, the agent immediately analyzes the incident, conducts root-cause investigations across historical logs, gathers the relevant code context, and prepares an action plan before he has even viewed the message. This automated triage saves critical minutes during outages and eliminates the cognitive burden of manual log analysis.
He expands this concept to product management and application development using the example of a food recipe application. Once deployed, an agent can manage both feature enhancement and bug triage lifecycles. If a developer posts a ticket requesting support for a new cuisine, the agent inspects the code repository, plans the required architectural changes, implements the feature, and submits a pull request for human review. Similarly, if an end-user submits frustrated feedback about an application glitch, an automated workflow ingests the report, isolates the reproduction steps, patches the bug, and pushes a proposed fix directly into the review pipeline. Implementing these continuous proactive loops has made Khandelwal approximately "5X more productive," preventing communication blind spots where unaddressed messages could otherwise languish for weeks.
- **Codex Background Workflows:** Automatically running research, log evaluation, and triage on incoming peer queries and operational alerts.
- **Continuous Feedback Loop:** Converting raw user feedback and error reports into actionable pull requests without manual developer mediation.
- **Productivity Acceleration:** Claimed 5x efficiency gains by delegating administrative triage, context gathering, and initial draft PRs to agents.
---
[17:31](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=1051s) Scoped Rollout: Adopting a "Read-First" Enterprise Strategy
In his concluding remarks, Khandelwal offers guidance for organizations looking to adopt agentic workflows without introducing security or operational risks. He warns that granting autonomous agents unrestricted write permissions from day one is dangerous: "Because if you don't do scoped actions, you all know what's going to happen." Instead, enterprises should approach implementation through a structured, staged rollout.
Teams should begin by targeting a single, high-friction workflow that wastes significant manual effort. The recommended rollout begins with a "read-first approach," where the agent is granted permission only to ingest context, observe tickets, scan logs, and synthesize diagnostic summaries. During this phase, the agent presents findings and proposed resolutions to human operators for validation. As confidence in the agent's accuracy and stability grows over time, administrators can progressively expand its permissions to execute scoped actions—such as modifying configuration files, granting standard permissions, or publishing pull requests. By closing the loop with continuous monitoring and outcome verification, organizations can build secure, resilient agents that reliably reduce workflow friction.
- **Implementation Step 1:** Identify a single repetitive, friction-heavy business or engineering workflow.
- **Implementation Step 2:** Deploy the agent under a strict "read-first" policy to observe data, summarize context, and propose actions without execution authority.
- **Implementation Step 3:** Validate model accuracy and establish operational confidence through human oversight.
- **Implementation Step 4:** Gradually grant carefully scoped write and execution permissions behind strict boundary constraints.
## Notable quotes
> moving from a simple AI interaction to an agent that can reliably complete real-world work requires thoughtful orchestration, clear workflows, and effective human oversight. — Dikshit Khandelwal
> Through a synthetic demonstration, I will illustrate how an agent can interpret an employee request, build a plan, coordinate actions across enterprise tools, incorporate human approval where appropriate, handle partial failures, verify outcomes, and report results back to the user. — Dikshit Khandelwal
> move beyond the prompt and build AI agents that reduce workflow friction, automate repetitive processes, and make enterprise work faster and more reliable. — Dikshit Khandelwal
> [10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) nurturing a baby — Dikshit Khandelwal
> [10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) who am I? — Dikshit Khandelwal
> [10:07](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=607s) what can I do? — Dikshit Khandelwal
> [12:34](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=754s) 5X more productive — Dikshit Khandelwal
> [17:31](https://www.youtube.com/watch?v=WbgJtYCpWn4&t=1051s) Because if you don't do scoped actions, you all know what's going to happen. — Dikshit Khandelwal
## Video description
Dikshit Khandelwal - Member of Technical Staff, Platform and Security, OpenAI
AI agents have the potential to transform how enterprises automate complex workflows that span multiple systems, tools, and teams. But moving from a simple AI interaction to an agent that can reliably complete real-world work requires thoughtful orchestration, clear workflows, and effective human oversight.
Through a synthetic demonstration, I will illustrate how an agent can interpret an employee request, build a plan, coordinate actions across enterprise tools, incorporate human approval where appropriate, handle partial failures, verify outcomes, and report results back to the user.
Attendees will learn practical patterns for designing enterprise agents, including workflow orchestration, human-in-the-loop interactions, tool integration, failure handling, retries, outcome verification, and observability. Join this session to learn how organizations can move beyond the prompt and build AI agents that reduce workflow friction, automate repetitive processes, and make enterprise work faster and more reliable.
Dikshit Khandelwal of OpenAI argues that enterprise automation is transitioning from reactive conversational prompting to proactive AI agents integrated directly into collaborative workspaces. Under this model, agents continuously observe systems, cross-reference operational procedures, and prepare interventions for human approval before manual triage even begins.
From Reactive Prompting to Proactive Incident Response (3:10)
Traditional enterprise artificial intelligence relies on a reactive posture where employees prompt a chatbot and manually transfer outputs across external tools. Khandelwal advocates shifting to a proactive architecture in which autonomous agents continuously observe operational environments, interpret context, and act upon anomalies without awaiting explicit human instructions.
To demonstrate this difference, Khandelwal highlights engineering on-call rotations. When an incident occurs at 3:00 AM, a reactive response requires an engineer to wake, log in, and manually inspect thousands of log lines. In contrast, an automated agent ingests the alert immediately, isolates the root cause, reviews the repository, and drafts a pull request with a proposed fix within 15 to 20 seconds, leaving the engineer solely to evaluate and approve the deployment.
Embedding Agents and Playbooks in Shared Workspaces (6:11)
Rather than forcing users into separate AI interfaces, Khandelwal recommends introducing agents as active teammates within shared collaboration surfaces like Slack, Jira, or Linear. Operating within these tools, the agent ingests work items, grounds its actions in organizational documentation and standard operating procedures (SOPs), and executes an operational loop of planning, tool use, verification, and feedback. If policy requires human sign-off, the agent pauses and requests guidance directly within the shared thread.
To ensure control, Khandelwal emphasizes establishing structured playbooks that define the agent's identity, allowed capabilities, accessible microservices, and hard boundaries. In internal IT service desk environments, an agent can parse employee inquiries regarding permissions or hardware, autonomously implement standard changes that satisfy security criteria via back-end enterprise APIs, and escalate ambiguous or sensitive requests to human administrators with gathered context.
Autonomous Triage Across the Software Lifecycle (12:34)
Continuous background agents can also automate developer support triage and feature delivery. Working within OpenAI's Codex ecosystem, Khandelwal runs background workflows to investigate alerts, evaluate historical logs, and draft resolution strategies before opening peer inquiries or alerts. He reports that delegating administrative triage, context gathering, and initial pull request drafting has made him approximately five times more productive.
This continuous loop applies across the broader application lifecycle. Using a recipe application as an illustration, Khandelwal shows how an agent can ingest feature requests or bug reports, determine code changes, implement modifications, and submit a pull request for human review. This structure converts incoming telemetry and user feedback directly into actionable code updates without manual developer intervention at the triage stage.
Mitigating Operational Risk with Read-First Deployments (17:31)
Granting autonomous agents broad write permissions across corporate infrastructure poses significant security and operational risks. Khandelwal warns against deploying fully autonomous agents immediately, urging organizations instead to start with a single, high-friction workflow.
He recommends adopting a phased rollout centered on a "read-first" posture. In this initial stage, the agent is restricted to observing tickets, scanning logs, and producing diagnostic summaries for human review. Once monitoring verifies the model's accuracy and stability, administrators can progressively expand permissions to execute scoped write actions, such as altering configuration files, granting permissions, or submitting code.
Khandelwal concludes that shifting to proactive agents enables significant efficiency gains, but successful adoption requires constraining systems through structured playbooks and staged permissions rather than granting unmonitored write access.
Dikshit Khandelwal: moving from a simple AI interaction to an agent that can reliably complete real-world work requires thoughtful orchestration, clear workflows, and effective human oversight.
Dikshit Khandelwal: Through a synthetic demonstration, I will illustrate how an agent can interpret an employee request, build a plan, coordinate actions across enterprise tools, incorporate human approval where appropriate, handle partial failures, verify outcomes, and report results back to the user.
Dikshit Khandelwal: move beyond the prompt and build AI agents that reduce workflow friction, automate repetitive processes, and make enterprise work faster and more reliable.
[10:07] Dikshit Khandelwal: nurturing a baby
[10:07] Dikshit Khandelwal: who am I?
[10:07] Dikshit Khandelwal: what can I do?
[12:34] Dikshit Khandelwal: 5X more productive
[17:31] Dikshit Khandelwal: Because if you don't do scoped actions, you all know what's going to happen.
[17:31] Dikshit Khandelwal: read-first approach
Original transcript
[0:04] Hi everyone. My name is Dikshit Khandelwal.
You can call me DK. I currently work at Open AI
[0:10] managing infrastructure internal infrastructure
for enterprises. And my major role is mostly
[0:16] related to building platform and managing internal
devices for that. And I'll be presenting about how
[0:24] we can automate enterprise enterprise workflows
using AI agent. And we we all work in companies
[0:32] and the major goal is to improve productivity.
And how we can automate that stuff. That would
[0:37] be my goal. Today the my goal is also for you
to understand that this is just a framework that
[0:44] everyone can use. They can use in their actual
real life to improve their own productivity
[0:49] and at the same time improving the enterprise
productivity also. So it goes every single place.
[0:55] And that's how I automated most of my stuff making
these slides, you know, making it beautiful. So
[1:04] All right. So just to overview how we going to
start about is first I want you to understand that
[1:10] what phase are we in. We've been interacting with
AI. We hear a lot about AI how we started before.
[1:17] So I want you to understand that what stage
are we in in the sense of AI what tools we
[1:21] have and all that stuff. And how we how
we can utilize all of that stuff. Then
[1:26] what's the idea behind how we can automate
enterprise workflows rather than just like
[1:31] you know, we go to chat GPT talk to it find
the answers. That's that's cool. That's nice.
[1:37] Like you know, it's helping us to improve our
productivity. We have to do less of our jobs.
[1:42] So it's improving but how we can scale this up
to help our customers. Right? We have all of our
[1:48] customers how we can improve their experiences and
at the same time how we be more productive towards
[1:56] it. And then lastly like a little bit more of
like how we system this and how we architect this.
[2:03] My goal is to, you know, just have a baseline
framework towards it. So, everyone can understand
[2:09] that oh, once I'm home, like how do I build this
my own? So, that would be my goal. And in the end,
[2:14] just an example that how I am using this and how
like my team uses this to automate it. So, we like
[2:22] years years back, decades ago, we started with
assembly language. Then there was C interpreters,
[2:27] Python. Today, like few years back, we started
with chat GPT. Today, we have like, you know,
[2:32] prompted, you find answers, cool answers. I use
it every single day to automate all of my stuff.
[2:38] But now we have moved into an era where everything
is agentic. And when I say agentic, it's not just
[2:45] a chatbot. It is more than that. So, basically,
like today it should be interacting in a way that
[2:52] hey, if you have a question, it will answer it
that simple and like a chatbot, but it should
[2:56] do more than that. Uh like maybe cook food for me,
like end-to-end process. So, something like that,
[3:03] it goes through a whole workflow. Rather than
just, you know, go find an answer for me. So,
[3:10] the idea behind is today, like it was like more
reactive approach by, you know, finding answers,
[3:17] finding solutions, and we work with our own
customers that hey, this is a thing. Like this is
[3:23] the answer for you. Have we helped each other or
not? That is mostly like, you know, how I used AI
[3:30] to answer someone else's question. But now
we want to take a different approach towards,
[3:35] you know, using this agentic agentic workflows,
which is more of a reactive approach. Sorry,
[3:41] proactive approach. Reactive was something, you
know, chatbots, I know the answer. Now proactive
[3:47] approach is more of like how we run through the
whole workflow. So, instead of you going in and
[3:54] saying, "Hey, can you do this job for me? Like,
write the code for me?" Instead of doing that,
[3:59] I want that agent to understand that what
is the context, what is going on over here,
[4:05] and being more proactive than me. So, I don't
have to say, "Hey, do this and do that." So,
[4:11] agent should understand that, "Hey, oh [ __ ] like
I have this I've got this request. I need to act
[4:17] on it and find some solutions." For example, like
engineers get on-call stuff. Uh 3:00 a.m. they
[4:24] get pinged, paged on it, and they're like, "Oh,
damn, I have to find answer what's broken now."
[4:29] Like, what if like if the agent is going by
itself finding the root cause of it and finding a
[4:35] solution even before you get on your computer, and
it gives you the whole thing summary what's broken
[4:39] down, and it tells you, "Hey, this is a fix.
I have a PR for you. I have this already done.
[4:46] I just need a human approval so I can go ship into
production." So, that's more of like, you know,
[4:51] agentic approach that we are approaching towards.
Uh so, basically, the idea is just like we are
[4:57] not shifting like everything, you know, just AI
should do it. We are just working with AI today.
[5:07] So, this is just an example of, you know, like
we have This is cool to have, like, you know,
[5:12] I have connected all of my tools. I have like Doc,
uh Google Docs, Figma, GitHub, Jira, Linear, Slack
[5:20] at one place. It's nice. It will go understand
those, find some context, but at the same time
[5:26] in the end, you know, I have to tell, "Hey,
can you create this new app for me?" And also
[5:32] in enterprise environments, let's say like,
uh talking about IT workflows, there are like
[5:36] tons of tickets that we get in every single day to
find uh to find some solutions for their problems.
[5:43] Like, I will have to go investigate things. Even
though like if I can integrate all of that stuff,
[5:48] this workflows can be easily built where it the AI
agent is automatically understanding things. Oh,
[5:55] I got a request and there is this issue. I already
have a lot of context from every single place.
[6:01] I know I can take actions on it
with certain guardrails, of course.
[6:04] And then it should go by fix it by self
if you define a workflow in a better way.
[6:11] So, the core idea over here is how we take this
approach is with shared human AI workspace. So,
[6:21] what I mean by that is when I when we
want to reach towards proactive approach,
[6:26] we just don't want all of the plugins
and connectors come like, you know,
[6:31] connected to our chatbot. We want to make
something where we can invite the AI agent to our
[6:38] workspace and work with it. So, when I say, for
example, we have Jira dashboards, we have linear,
[6:46] we have Slack. Like I want to invite my agent to
come inside it and act like that to understand
[6:53] what's going on. Because I gave it a place
that, "Hey, now I am inside the Slack channel
[7:00] itself. I know what's going on, what problems
like the I'm getting, what ticket request I'm
[7:06] getting in." So, it understood that. At the
same time, the next thing is like uh just like
[7:13] it it can track things. Let's say if you want
have a new bug that you want to fix, just create
[7:19] it we create a ticket. There is a whole automation
workflow where it goes find things out and it will
[7:25] investigate. It will plan for you. And then it can
automatically update that particular ticket. Hey,
[7:32] it was in progress right now. I implemented this
task. It's waiting for a human approval now.
[7:37] So, it's your job. Approve it. If you think
anything wrong, comment it on it and I will go fix
[7:42] it for you. So, it's more of like I have created
a whole workflow rather than just like, you know,
[7:50] I go in like telling each and every step for it to
do. All right. So, it starts with like, you know,
[7:58] a shared workspace where I invite my AI agent.
This is very general thing. Uh I generalize it
[8:04] very easy uh like in a small way, but this can
be anything. Uh whatever tool that you use,
[8:11] it can be linear, it can be Jira, it can be Slack
channel. Wherever, you know, you get requests in,
[8:16] you get tickets in. What workflow you're trying
to optimize it using AI agent. So, this is like a
[8:24] just like simple high-level framework, but it
depends on, you know, person to person what
[8:30] they're trying to automate it. Next thing is once
we get in a request, then we have a knowledge base
[8:37] that I have lots of documentation. For example,
like everyone like if I talk about more of IT,
[8:44] then we like docs, SOPs, what is the procedure in
this use case, what should I be utilizing? What
[8:53] are my steps to follow? So, that's a knowledge
base. And then when I talk about tools access,
[8:58] what that AI agent can perform. So, basically
today I don't want it just to answer question.
[9:03] I want it to do the job for me. So, it's
like not writing code, but do things
[9:09] that a user can do it on that behalf, but
with certain guidelines, of course. So,
[9:15] it's up to us what workflows we are defining, and
I will give a better example like how I am using
[9:20] in my own life to improve my own productivity,
and also at the same time my team's productivity.
[9:28] And then like once we have that request with a
work object, it goes through our agent runtime.
[9:34] It will see what's the issue that's going
on. It will plan it. It will build it and
[9:39] test it out everything depending on what
workflow we have built and use that context
[9:44] and at the same time repeat repeat the action. Uh
I have a slide where it says like when I repeat it
[9:51] did I do a good job on it? If not, then learn from
it. So, more of like this is just another slide.
[10:01] I think we can skip this one. So, a real-life
use case what what I have we've been doing is
[10:07] with my team. Uh we have Slack channels. So, we
get a lot of internal request within IT that hey
[10:15] I have this broken device. I don't have access to
this permission. I my machine is not working fine.
[10:22] Can I get access to some random group? Can
I get a exception? All of these tasks can
[10:27] be automated in a nicer way. Uh for example, uh
just for exception request. If it's a for a IT,
[10:35] you get in the request. I have this AI agent which
is approved for giving exception request depending
[10:41] on if security approved it or not. So, I can build
a workflow where the agent will be inside my Slack
[10:48] channel looking at all of those requests what's
is incoming and depending on what skill set I
[10:54] have given it, what tools access I've given it,
it will understand that and take those actions.
[11:02] So, my job would be is like building a good
workflow which is secure enough and doing
[11:09] its own thing what I tell it to do. Then, it will
take that request in. I have a agent playbook uh
[11:17] which just defines that who am I? Like what is
this agent for? Then, I have like what can I do?
[11:25] Then, what services access do I have? What uh what
is this service about? What tools access I have?
[11:33] And then with certain boundaries like boundaries,
I define in the skills and playbook for that
[11:39] agent. It's like a you know, you just how you
nurture a baby like, "Hey, you are this. This
[11:45] is your name. You like to do this." And how
it it will evolve itself slowly slowly slowly.
[11:51] So, with some boundaries of course, you know,
we we we do the same thing with children. Uh
[11:57] then we have like let's say we have like team A,
team B. We have two like multiple services like we
[12:02] have like lots of services we have to manage. And
to automate all of that task, it's like internal
[12:08] request coming from Slack. AI agent reads it,
understands it what it needs to do. And once it
[12:14] it has a context, it can go to those services
and like you know, "Give me the exception."
[12:19] So, it's like I build a whole workflow towards it.
And then uh whatever the performance uh perform
[12:26] action would be, it will be like that. Uh one of
the examples uh I would give over here is I uh
[12:34] first talked about how So, as an engineer, I'm
an engineer. So, one of the thing that I was uh I
[12:42] get pinged like 3:00 a.m. sometimes in the morning
and it's like kind of like I like to sleep. Uh so,
[12:50] I wanted to automate thing where you know,
instead of just me going in, I get a page.
[12:57] And I'm like, "What's broken? I have no idea."
What's the first thing I'm going to do? I'm going
[13:02] to open my code X. "Hey, this is a thing going
on. Can you help me find it out what's going on?"
[13:08] So, instead of doing that like I thought like why
don't I cannot automate all of that stuff when I
[13:13] get a page myself? The first thing it should get
it should trigger some kind of workflow where hey,
[13:20] this is I got a page. The AI agent goes, finds
some context what's broken and what's the code,
[13:26] what perform actions it can take? And then,
before I open my lid in those like 15-20 seconds,
[13:33] it already knows what's the core cause. The
like thousand thousands of logs I have to go
[13:37] through. It can go through easily very quickly and
find the solution of it. So, it's like that and
[13:45] within those 15 minutes, I have the answer. Like,
I don't have to go through all of those log. It
[13:49] already did its job. All I have to do is do a
human review on it. If it's good, we ship it to
[13:55] production. Like, bug bug is fixed. So, that's how
like these is This is just one example that like
[14:02] we can solve, but this is more of like, you
know, we can use the same framework in enterprise
[14:09] workspace or to improve your own productivity.
So, you can set up workflows where every single
[14:15] messages that you're getting from your colleagues,
"Hey, can I get a review on this? Can you Do you
[14:19] know more context on that stuff?" It all The
workflow automatically gets triggered. So,
[14:24] I have like multiple workflows for my own
productivity within my Codex, where it keeps
[14:29] running automatically. And if we get a request
in for my like specifically if I'm on call stuff,
[14:36] before I even see the message, it goes in, does
the research, what's broken, or what do I need
[14:44] to do, and then it will give me a whole summary of
it, what's going on, what actions I need to take.
[14:51] So, that's the idea of it. Okay. So, this is
more of like workflow uh we release things,
[14:59] notify, monitor, and learn from the activities
that we have done. One great example is uh
[15:06] let's say you are building a app. Now, that app
does a lot of things like depending on what's
[15:11] your use case is. Let's say if I'm building a food
recipe app, uh that's a product now. I build that
[15:19] app, I publish it online. Done. Now, I can After
this, if I build a really good workflow around it,
[15:27] then what's going to happen is I go to my ticket
tracking system. I will just say that hey, I need
[15:34] to add a new feature where we, you know, where to
add a new new a different cuisine. So, it will do
[15:42] its own research what what I need to do. It will
understand the whole app. And then, it will create
[15:50] those changes and then send me to for approval
instead of me going in doing each and every stuff.
[15:56] I give it access to different platforms I need,
uh what actions it can take and all that stuff.
[16:02] Similarly, let's say someone is using from this
audience if someone is using this app for like
[16:09] my own recipe thing I created, and they notice
there is a bug and they are super frustrated,
[16:15] they they just report something wrong and they
comment it out on it feedback as a feedback.
[16:22] It should be like, hey, it's a workflow another
workflow I built where it just reads your own
[16:28] request, what's the bug in it, and it goes through
the whole loop of like, oh, I will fix this bug
[16:35] and creates a PR for me and to ship it into
production. So, that's the idea behind it is uh
[16:41] what I want everyone want to what I want
everyone to use it like as a framework
[16:48] either to include in the enterprise workflows
or in to for your own productivity. Because
[16:55] I have improved my productivity by a lot. Uh it
might sound crazy, but I believe like maybe five X
[17:02] I'm more productive than what I used to be without
AI agents and more of like a proactive approaches.
[17:09] And sometimes like trust me like if I didn't have
this workflow that I built, it would be like I
[17:15] miss out few messages and I don't like it would be
like, "Oh [ __ ] I forgot to reply back to you."
[17:21] My bad. It will be after a month. So, that's the
idea. And uh lastly just like a pick a workflow
[17:31] whatever what you are trying to optimize uh within
your company or what workflow what you are where
[17:37] you are trying to be productive, then think of it
like you know how you can automate this stuff. Uh
[17:45] in a more proactive way where you don't
have to interact with it. And it takes
[17:51] it takes approach of more proactiveness, and then
in the end when you it needs a review because
[17:56] yeah, of course, we need a human review until
we reach reach all the way in the end, right?
[18:02] Do that. Maybe like read read first
approach find like more proactive Hey,
[18:08] this is the thing. And then once you have more
confidence on the workflow that you have built,
[18:13] then we can go scope out you can you have
a permission to take actions on it now
[18:18] rather than just you know telling me I me
taking help from me. And then if you see like
[18:26] there is some issue with it, go improve yourself.
So, we created a whole loop building a workflow
[18:32] read only secure enough and at the same time
like scoped actions what it can do because
[18:39] if you don't do scope actions, you all know what
going to happen. Yep, I think that's it. Uh Uh
[18:47] that's all I had, but if you have if anyone have
any questions, uh feel free to ask me, but you can
[18:54] add me on LinkedIn. I love talking about different
things whatever I have, but thank you so much.
