OpenAI DevDay 2025: The Workflow Game-Changers
From ChatGPT Apps to AgentKit: OpenAI's Upgrades are Transforming AI Workflows
OpenAI basically said “what if we just... did all of that for you?”
Yesterday OpenAI dropped three updates that made me stop mid-coffee and actually pay attention. Not because they’re flashy, but because they finally solved the most annoying part of AI tools: the constant context-switching between chat windows, automation platforms, and creative apps that makes you question why you started using AI in the first place.
Here’s what happened: ChatGPT can now run actual apps inside your conversation. That’s right, no more copying and pasting between tabs to create a deck in Canva or book that hotel ChatGPT recommended for your upcoming trip to Atlanta. Now, you can just ask, and your apps open right there in the chat thread.
Meanwhile, OpenAI launched AgentKit for anyone who’s ever tried to build an automation and thought “there has to be a better way to do this.” It’s drag-and-drop agent building that doesn’t require three YouTube tutorials to understand.
And then there’s Sora 2’s API, which basically hands you the keys to the same cinematic video generation that’s currently breaking the internet.
Want to make something like this? Grab my free Sora 2 Prompting Guide, with studio-quality prompting tips for making Sora videos.
The timing couldn’t be better. We’re at this weird inflection point where everyone knows AI can theoretically transform workflows, but most of us are still manually copying prompts from one tool to another like it’s 2019. These updates change that dynamic completely.
With apps inside of the chat thread, ChatGPT becomes your actual workspace, not just a chat window. AgentKit turns complex automation from a developer-only skill into something you can build over lunch. And Sora’s API means the video content that used to require a production team can happen with a well-crafted prompt.
What makes this different from every other “game-changing” AI announcement? These tools actually ship ready to use. Apps in ChatGPT work today. AgentKit is live with visual builders and pre-built connectors. The Sora API is serving requests right now.
Let’s walk through exactly what each update does, who should care, and the specific workflows you can build starting immediately. Because the gap between people who figure this out now and everyone else is about to get significantly wider.
Apps in ChatGPT: Your Entire Workflow Lives in One Chat Now
Remember when AI tools meant juggling fifteen browser tabs while your laptop fan screamed for mercy? OpenAI just killed that entire workflow. Apps now run directly inside ChatGPT conversations—not as clunky plugins you activate in settings, but as natural extensions of whatever you’re already talking about.
Here’s the shift: You’re planning a trip to San Diego. Instead of copying flight details into Expedia’s search bar, you just tell ChatGPT what you need. The Expedia app opens right there in your chat thread, shows you flights with interactive buttons, and books everything without leaving the conversation. Your context stays intact. Your flow stays unbroken.
The apps aren’t just text responses dressed up fancy. They’re full interactive interfaces—think mini-portals that appear when you need them. Creating a social media graphic? Canva’s design tools pop up mid-conversation. Building a playlist for your workout? Spotify’s interface materializes without you asking. ChatGPT actually watches your conversation and suggests relevant apps before you realize you need them.
This works because OpenAI built something called the Model Context Protocol (MCP). Basically a universal language that lets any app speak fluently with ChatGPT. Developers get an open-source SDK to build these integrations, which means the boring technical plumbing is already done. The apps just… work.
ChatGPT Apps: Real-World Use Cases
When AI stops being a search bar and starts being your workflow
Let’s get tactical. You’ve heard ChatGPT can run apps now—great. But what does that actually mean when you’re trying to book a last-minute trip at 11 PM or scrambling to create presentation slides the night before a conference? Here’s exactly how to use these app integrations to solve real problems, with the actual prompts that make them work.
Use Case 1: The “I Need a Vacation Yesterday” Workflow
The Old Way: 15 browser tabs, three apps, decision paralysis
The New Way: Conversation → Decision → Done
1. Expedia prompt: “Find me weekend getaways from Chicago under $600 total (flight + hotel) leaving this Friday. I want somewhere I can actually relax - no cities, think beach or mountains.”
2. Then Booking.com: “Show me spa hotels in [chosen destination] with availability this weekend.”
3. Finally, Spotify: “Create a ‘Beach Chill’ playlist for my trip - 2 hours of laid-back vibes, mix of indie and classic chill.”
Why it matters: Each app handles its specialty, but ChatGPT is your travel agent brain holding it all together.
Use Case 2: The “I’m Speaking at a Conference Tomorrow” Panic The Scenario:
You’ve been procrastinating. It’s 10pm. You need to look professional.
1. Canva prompt: “Create a presentation about ‘Automating Your Small Business with AI’ - 12 slides, professional blue/white theme, include sections for: problem, solutions, case studies, next steps.”
2. Then refine: “Make slide 4 more visual - add icons for each automation benefit.”
Why it matters: You went from blank screen to polished deck without leaving the conversation. That’s the real unlock.
Use Case 3: The “Am I Ready for a Career Change?” Investigation The Dilemma:
You want to pivot but don’t know where to start.
1. Coursera prompt: “I’m a marketing manager wanting to move into UX design. Find me a 3-4 month learning path with hands-on projects. I can dedicate 10 hours/week.”
2. Follow-up: “Which course should I start with if I’ve never used design tools before?”
3. Later, with Figma: “Open a basic UI design tutorial and walk me through creating my first mobile app mockup.”
Why it matters: From research to education to hands-on practice - all in natural language.
Use Case 4: The “We’re Moving and I’m Overwhelmed” Situation The Reality:
Life-changing decisions shouldn’t require spreadsheets.
1. Zillow prompt: “Show me family-friendly neighborhoods in Austin, TX - homes under $450k, good schools, low crime. Display on a map so I can see clusters.”
2. Follow-up: “Compare these three specific addresses - walkability scores, nearby amenities, and property tax estimates.”
3. Then Expedia: “Book me flights and a rental car to Austin next month - I need to tour these neighborhoods in person.”
Why it matters: Interactive map + data + action, all driven by conversation.
AgentKit Turns You Into an Automation Architect (No Coding Required)
While ChatGPT apps handle your immediate tasks, AgentKit tackles something bigger: building AI agents that run your entire workflows autonomously. Think of it as the difference between having a really smart assistant and training an entire team of specialists.
The visual builder for agent creation. You’re literally dragging logic blocks around a canvas, connecting data sources like Dropbox or Slack with a few clicks, and watching your agent come to life in real-time. No YAML files. No debugging mysterious API errors at 2 AM. Just point, click, and watch your automation take shape.
Here’s where it gets interesting: AgentKit includes built-in guardrails that prevent your agents from going rogue. Set boundaries around what data they can access, what actions they can take, and when they need human approval.
Your customer service agent can draft responses but not send refunds over $100. Your content agent can schedule posts but not delete your entire archive.
The Connector Registry is a menu of pre-built integrations. Need your agent to pull data from Google Sheets, update records in Hubspot, and notify your team in Microsoft Teams? Those connections already exist. You’re not building bridges, you’re just deciding which ones to cross.
Agent Builder: Drag-and-Drop Meets Actual Intelligence
Visual builders usually mean “looks pretty, barely works.” Agent Builder is different. You’re not just connecting boxes—you’re orchestrating intelligence.
Picture this: You drag in a customer inquiry node. Connect it to a knowledge search. Add a decision branch for escalation. Drop in a response generator. Hit deploy. That’s not a flowchart—that’s a working customer service agent.
The interface shows you agent reasoning in real-time. You can watch it think, see which tools it’s invoking, understand its decision logic. When something goes wrong (and it will), you can trace exactly where and why, then fix it without rebuilding everything.
During the DevDay demo, they built a document comparison agent in under eight minutes. Not a prototype. Not a proof of concept. A working system that could analyze contracts, flag differences, and summarize changes. Eight minutes.
Why Your Current Setup Just Became Optional
Here’s what OpenAI figured out: The problem wasn’t that we needed better individual tools. The problem was that our tools couldn’t actually talk to each other without extensive middleware gymnastics.
Your Zapier workflows? They’re translators between systems that don’t speak the same language. Your Make scenarios? They’re elaborate workarounds for tools that won’t cooperate. Your custom code? It’s mostly handling errors when Service A doesn’t play nice with Service B.
AgentKit eliminates the translation layer. Everything speaks the same language, uses the same context, shares the same state. Your agent doesn’t need to explain what it’s doing to seventeen different services. It just does it.
Agent Builder collapses weeks of work into minutes of configuration. And when something needs tweaking? You’re adjusting a visual flow, not debugging code across three different platforms.
The real question isn’t whether you should explore this. It’s whether you can afford to wait while your competitors are already building agents that work while they sleep.
Agent Building Best Practices: The Foundation Rules That Separate Working Agents from Expensive Experiments
Here’s your implementation blueprint – follow these in order and you’ll build agents that work the first time:
Your Agent Builder Checklist
Phase 1: Architecture (Before You Touch the Canvas)
□ Define ONE core job. Agents that do everything do nothing well. Pick one workflow to master first.
□ Map your golden path. Document the ideal flow when everything works perfectly (80% of cases)
□ List your edge cases. Write down the weird stuff that happens 20% of the time
□ Choose your model intentionally. Not everything needs GPT-4o. Use cheaper models for simple routing
Phase 2: Schema & Structure (Your Agent’s Brain)
□ Create strict output schemas. JSON templates for every response type (prevents hallucination)
□ Build input validation rules. Define exactly what your agent accepts (blocks garbage data)
□ Set response boundaries. Maximum token limits, approved action lists, forbidden territories
□ Design state management. How your agent remembers context across conversations
Phase 3: Tool Integration (The Power Tools)
□ Start with native tools only. Web search, file search, computer use – master these first
□ Add one external tool at a time. Each integration exponentially increases complexity
□ Build fallback behaviors. What happens when a tool fails or returns unexpected data
□ Create tool hierarchies. Which tools get priority when multiple could solve the problem
Phase 4: Guardrails & Safety (Your Insurance Policy)
□ Implement prompt injection protection. Test with adversarial inputs immediately
□ Set resource consumption limits. API calls, compute time, token usage caps
□ Build approval workflows. Human-in-the-loop for sensitive actions (payments, deletions)
□ Create audit logging. Every decision, every action, every reasoning step tracked
Phase 5: Observability Setup (Your Debugging Superpower)
□ Enable full tracing from day one. You can’t fix what you can’t see
□ Create performance baselines. Response time, accuracy rate, completion percentage
□ Build evaluation datasets. 20-30 test cases covering your golden path and edge cases
□ Set up alert thresholds. Get notified before things break, not after
Phase 6: Testing & Iteration (Where Agents Become Reliable)
□ Run edge case stress tests. Throw your weirdest scenarios at it
□ Test with real data samples. Your production data is messier than your test data
□ Measure actual vs expected outputs. Track deviation patterns
□ Document failure modes. Know exactly how your agent breaks
Phase 7: Production Deployment (Going Live Without Drama)
□ Start with shadow mode. Run parallel to existing systems without affecting anything
□ Implement gradual rollout. 5% traffic → 25% → 50% → 100%
□ Build rollback triggers. One-click reversion when things go sideways
□ Monitor user feedback loops. Actual humans will find bugs your tests missed
The Agent Implementation Reality Check
The time math is simple: Spend 2 extra hours upfront, save 20 hours of debugging and angry customer emails later.
Pro tip that’ll save you heartache: Start with your simplest use case first. Don’t build the Swiss Army knife agent on day one. Build the butter knife agent that does one thing flawlessly, then expand. My most successful implementations all started as single-purpose agents that grew capabilities over time.
Remember: these aren’t suggestions – they’re the difference between agents that demo well and agents that actually run your business. Every skipped checkbox is a future 3 AM debugging session waiting to happen.
Now stop reading about best practices and go build something that doesn’t break when real users touch it.
The Power Move: Using Them Together
ChatGPT apps solve your “right now” problems. You need to book a flight, edit a document, or create a quick design. The app appears, you complete the task, you move on with your day.
AgentKit handles your “every single time” problems. Customer emails that follow the same pattern. Reports that need the same data pulled weekly. Content that needs consistent formatting and distribution. You build the agent once, and it handles these workflows forever.
Then there’s Sora 2, your creative supercharger. It turns your prompts into cinematic videos that can fuel your marketing, storytelling, or client deliverables. No production crew required.
Imagine this workflow:
You’re launching a product next month.
In ChatGPT, you use the Canva app to create marketing assets on the fly during your brainstorm.
Next, with AgentKit, you build an agent that automatically posts those assets to all your social channels, monitors engagement, and intelligently adjusts your posting schedule based on performance—no manual steps required.
For your launch video, you prompt Sora 2 and generate a cinematic trailer that would’ve taken a whole media team to produce.
Every part is connected:
ChatGPT apps power quick creative bursts in the moment.
AgentKit takes care of the ongoing, repetitive distribution and optimization.
Sora 2 fuels your launch with high-impact video, on demand.
And you stay in control:
ChatGPT apps show upfront exactly what data they need.
AgentKit lets you mask sensitive data and add approval flows for important actions.
This isn’t just time-saving.
The teams that figure this out first aren’t just saving time, they’re operating at a fundamentally different level. While everyone else copies and pastes between tools, you’re having conversations that execute themselves.
Your Move: From Reading About Agents to Building Them
Look, I get it. You just read about OpenAI basically nuking your entire automation stack from orbit, and part of you is thinking “Great, another platform to learn, another subscription to justify, another tool that promises to change everything.”
Here’s what’s actually different this time: You don’t need to abandon what you’ve built. You don’t need to migrate everything tomorrow. You don’t even need to fully understand how Agent Builder works to start benefiting from it.
The smartest move isn’t to rebuild everything. Just pick your most annoying manual process and turn it into your first agent.
That client onboarding flow that requires seventeen copy-paste operations? Perfect candidate. The daily report you compile from four different dashboards? Agent material. That competitor monitoring you’ve been meaning to automate for six months? Your agent can handle it by lunch.
Here’s your homework for the next 24 hours:
Step 1: List three processes you do manually that eat 30+ minutes each. Don’t overthink this – pick the ones that make you audibly sigh when they show up on your calendar.
Step 2: Choose the simplest one. Not the most important, not the most impressive – the simplest. Your first agent should be a confidence builder, not a science project.
Step 3: Block 90 minutes this week to build it. Not to plan it, research it, or create a strategy document about it. Build it. Follow the checklist, keep it simple, and ship something that works.
The companies that’ll dominate the next five years aren’t the ones with the biggest AI budgets or the fanciest consultants. They’re the ones whose people started building agents today while everyone else was still debating whether this is “just another trend.”
You’ve got the blueprint. You’ve got the tools. You’ve got processes begging to be automated. The only thing standing between you and your first working agent is the decision to start.
The beautiful part? Once you build that first agent and watch it handle real work while you sleep, you’ll wonder why you waited this long. Then you’ll build another. And another. And suddenly you’re not just using AI; You’re commanding an army of digital workers who never need coffee breaks.
So here’s my question: What’s the first soul-crushing task you’re going to hand off to your new agent?
