When MasterClass reached out about building a course for the AI era, it felt surreal.

Even more so because I’d get to do it with two of the best in the field, Stanford economist Erik Brynjolfsson, and my good friend, the legend, Cat Goetze.

Together with MasterClass, we built a new playbook for how work is changing in the AI era.

"Revolutionize Your Workflows with AI." is now live.

We cover:
→ Agents that operate on your behalf
→ Lightning-fast data analysis + prototyping
→ From transcription → insight → action
→ Multimodal systems that think, see, and act

This is the stack behind how modern knowledge work is evolving.

Why This Matters Now

Most people are using AI in isolation. They think of it as a chatbot that can search, write emails, or summarize documents.

Real leverage is when you start thinking of AI as an extension of your will and creativity. The systems you create, that learn and grow with you in pursuit of your own goals.

When you ask an agent to do complex financial analysis and planning before you make a big purchase or life decision.

When you connect it to your email, calendar, the tools you use every day.

Systems that work for you, help make sense of the chaos, letting you focus on the things that matter, so you can thrive in your own life.

In this course we offer you a mindset shift.

A way to build your own operating system.

What You’ll Learn

We’ve packed the class with real-world demos to give you practical, career-level leverage.

• The “One-Person Unicorn”: Learn “vibe coding.” Tell AI what you want, and it builds the tools and systems for you. For the first time in human history, one person can do what used to take an entire team, and I’m here to show you how.

• Become a Poweruser: Connect AI to tools you already use, such as Google Drive, Notion, and your calendar. Using agents like Claude Cowork and Zapier, you’ll create your own agentic OS, unique to your life and ambitions.

• Put AI Agents to Work: Build systems that run in the background. Create an agent to watch your inbox, sorting messages by urgency. This way, you can turn a chaotic list into a clear set of priorities.

• Amplify Your Mind: Use agents like Claude Cowork to analyze large datasets and model business scenarios. Spot risks, compare outcomes, and make smarter decisions.

Joining a Growing AI Library

This class is part of a major shift at MasterClass to lead the way in AI learning. It joins other specialized offerings like AI and Medicine, The New Rules of Wealth, and AI Strategy at Work.

MasterClass recently launched MasterClass Executive, a new kind of business school built in partnership with the University of Chicago Booth School of Business and OpenAI. I’m excited to be part of it and help builders like you navigate this fast-changing era.

How to Watch

The class is available now only on MasterClass. Check it out!

http://masterclass.com/parthpatil

If you, or someone you know, is looking to get to the next level with AI, consider sharing this course with them!

And for everyone that’s already signed up and reshared! THANK YOU! Your support on this journey means the world to me.

Stay curious,

parth

That is why the public is split.

Insiders feel the AGI. The broader public sees a glorified search engine.

This is a skill issue.

Reid Hoffman (co-founder of LinkedIn) has a name for the upside of this moment: Superagency.

Superagency is what happens when a critical mass of individuals, personally empowered by AI, begins to operate at levels that compound throughout society.

The idea that you can do more, faster, and with greater confidence.

The idea that you create more options for yourself tomorrow than you had yesterday.

Can you feel it?

AI is a power user tech (for now)

The difference between someone’s optimism and someone’s cynicism is usually simple.

How much time do they spend playing with the tools?

Not only at work. Outside of work too.

Because humans aren’t one-dimensional. And this is a general-purpose technology.

It would be a crazy oversimplification to only use this technology for your job.

You might not see it’s true power. You will see a chatbot. You will see autocomplete. You will see “search, but faster.”

If you live with it, you start to see different things. You learn at a faster pace. You gain new powers. It begins to take action on your behalf.

You start to feel increased agency.

Coding Agents: When Code Stops Being “Software”

Claude Code changed how I think about code.

Not because it made me faster at writing software.

But because it made it obvious that code is just a way to apply structure to reality.

Once you see that, the surface area explodes.

I used to think of code as something you apply after a problem becomes “technical.” Claude Code flipped that. It showed me that you can start with code earlier—before the problem even looks like software.

Expense reporting. Animation pipelines. Personal branding systems. Presentations. Home automation. Content ops. Research workflows.

None of these are “software products.”

They’re messy, human, half-formed problems. And that’s exactly why coding agents work so well on them.

A coding agent doesn’t ask, “Is this a real app?” It asks, “Can we decompose, automate, or simulate this?”

That shift matters.

When you see everyday tasks as something code can handle, you stop asking for permission. You stop asking whether a tool exists. You build the scaffolding yourself.

Claude Code made this legible.

It showed me that:

• Code can be lightweight and disposable.

• Scripts can be creative tools and repeatable processes.

• Automation can live at the edges of life, not just in production systems.

Most importantly, it made it clear that coding agents aren’t about engineering excellence.

They’re about agency.

They let you try ideas that you would typically avoid due to the high overhead. They collapse the distance between “this is annoying” and “this is solved.”

That’s why coding agents are the most powerful agents right now.

Not because they write perfect code.

But because they turn vague intent into working systems—fast enough that curiosity stays alive.

And, as it turns out, everything is a software problem.

My first practical swarm.

One system I rely on now that I did not rely on a year ago is multiplexing coding agents.

I run many coding agents, Claude Code, Codex, Gemini CLI at the same time. They stay on. They stay “in the project.” Each project has its own context.

This isn’t just about concurrency—it’s about keeping momentum alive across many different ideas.

Across all my projects. Personal and work. With powerful coding agents powered by frontier models like OpenAI Codex and Opus 4.5.

The result is that I try more things. I explore more paths. I build in directions I used to avoid.

I apply this to everything.

My ability to prototype systems has skyrocketed.

• I’ve lost my bias toward specific programming languages.

• I’m no longer intimidated by unfamiliar systems.

• I ask plenty of questions, even if they seem silly.

This approach helps me find high-leverage ideas. My curiosity drives me, and I connect my thoughts with the abilities of the latest models.

But I still face a constraint.

I’m still the bottleneck.

I operate at a higher level now. But, my experience, confidence, and skills still hold me back.

The irony is:

The more I automate, the more responsibility I take on. My work shifts to a broader, more creative and strategic level.

You actually have to prompt the model a thousand times.

People underestimate the effort required to get good at wielding AI.

There is no other way. You need reps. You need to make a ton of stuff.

And you need to study people who do the same thing. People with an obsessive relationship to learning the tools.

10,000 prompts is the new 10,000 hours.

If a person doesn’t use the technology, they are unqualified to talk about it.

Follow people who play the next game.

In 2025, I began to follow real practitioners.

This shift alone improved my ability to explore.

Less noise. More contact with reality.

Wisdom comes from experience, and experience comes from being in the game.

That’s the good news.

It means a valuable new persona is emerging: the practitioner.

Not the commentator. Not the spectator. Not the theorist. Not the person with opinions about tools they don’t use.

The practitioner lives with the tools long enough for them to change what they see. They ship. They build scaffolding. They find leverage in systems.

They see the world differently.

So I started paying attention to people who live inside the tools.

Coding automation, AI agents, and frontier LLMs

Dexter Horthy

Dexter Horthy is a builder and systems thinker working on how humans and AI agents collaborate inside real software systems. He created the term “context engineering” to describe how to design what an AI model sees while it works. This includes memory, tools, instructions, and limits. It helps agents reason, act, and safely fail in real-world settings.

Why I follow him: Dex focuses on where agents actually break in practice, and how to design systems that keep humans meaningfully in the loop.

Echo Hive

AI creator Echo Hive shares hands-on coding experiments and workflows through video. He makes and shares experiments. These include custom GPT tools, agentic “hive” workflows, and generative pipelines. You can replicate the real architectures, prompts, and integrations he showcases.

Why I follow him: Echo Hive shares real experiments, not just opinions. He publicly tests and develops new models and agent patterns.

AI and Creative Workflows

Dave Clark

Dave Clark is a creative technologist. He explores generative AI as a true visual and cinematic medium. His work combines text-to-image, video models, and design systems. Instead of one-off demos, he creates cohesive aesthetic worlds. His work uses models as tools in a studio. He iterates on mood, composition, and visual language to build taste, not just outputs.

Why I follow him: Dave treats AI like photographers treat cameras. He builds a point of view over time instead of chasing tricks.

Nem Perez

Nem Perez is a creative technologist and filmmaker. He explores how generative AI impacts storytelling, collaboration, and creative direction. His work blends filmmaking, tools, and community. He uses AI to make story prototypes. It helps him manage collaborators and rethink the entire film production process.

Why I follow him: Nem treats AI as a new storytelling medium and production model, not just a visual effect.

Don Allen III

Creative technologist using generative systems to build expressive, interactive media. Don works at the forefront of virtual worlds and creative workflows. He explores how science fiction turns interactive and real.

Why I follow him: Don blends craft with experimentation—and I’ve seen that curiosity up close, long before AI made it fashionable.

Momo Wang

Momo Wang is an award-winning animator and filmmaker. She is also an artist and creative director. People celebrate her for mixing artistic vision with stories from different cultures. She created Tuzki, a famous illustrated bunny. Tuzki became a viral emoticon on major messaging apps. It has also expanded into merchandise, media, and brand collaborations.

Why I follow her: she pushes aesthetics forward, not just capabilities.

Joe Salvatore

Joe Salvatore works as an AI-native editor and visual commentator. He packages fast-moving generative AI tools, model releases, and creative workflows. His breakdowns are sharp and focus on visuals. Joe’s feed helps designers and editors see what matters and how to use it.

Why I follow him: He makes sense of the chaos in AI releases. He shares clear signals, useful insights, and guidance for creative professionals.

King Willonius

Musical comedy creator behind “BBL Drizzy,” one of the first viral AI-native hit songs. His music video production skills with frontier video models are second to none.

Why I follow him: King Willonius shows how AI closes the gap between ideas and audiences. He delivers cultural moments with speed and taste.

Greg Beato

Greg Beato is a creator and commentator working with generative AI and creative media. He’s co-author (with Reid Hoffman) of Superagency: What Could Possibly Go Right with Our AI Future. Check out Bro Botz, the coolest new AI music project written and produced by Greg himself.

Why I follow him: Greg actually plays with frontier models—writing, producing, and editing real music videos and characters with them. Watching him build worlds in public turns abstract capability into lived craft.

Business and entrepreneurship

Catherine Goetze (CatGPT)

Catherine Goetze, or CatGPT, is a great example of a creator-entrepreneur. She first builds an audience. Then, she shares her journey. Finally, she offers products directly to them. She makes AI fun, friendly, and focused on people with easy-to-understand content. At the same time, she tests how to turn attention into real businesses. Earlier this year she launched Physical Phones, a hardware experiment that turns nostalgic landline phones into Bluetooth companions for modern smartphones.

Why I follow her: Cat shows that personality, vision, and distribution matter just as much as technology—maybe even more.

Allie K. Miller

Allie K. Miller is an AI entrepreneur, advisor, and educator. She turns advanced AI into practical business solutions. She creates playbooks and strategies for operators. Her work connects enterprise adoption, new model capabilities, and practical decision-making. It helps leaders shift from “AI curiosity” to real execution.

Why I follow her: Allie links what models can do to what organizations can use. She focuses on enterprise and large-scale businesses.

Intelligence is now on tap. What will you do with it?

Superagency occurs when people, empowered by AI, begin to redefine the boundaries of what is possible. They improve their own lives first, then influence teams, companies, culture and eventually society at large.

So yes: 2026 won’t be defined by intelligence. It will be defined by Superagency, and by who actually learns to wield it.

What will you create in 2026?

I thought I was good at the whole numbers thing. I could milk the corporate world for a decent salary as an analyst all my life and live in peace… but then ChatGPT came along.

After probably an anxiety attack or two…

I sat down and said: fine. I’m going to replace myself.

I started building a GPT that could talk to a database.

Automate analysis itself.

The thing that I do really well.

And the wild part is: it taught me how. Natural language to SQL. API calls. Setup.

For the record, I wasn’t a real programmer back then. Really more of a data analyst. I’d used SQL and Python for data analysis work. But that’s not the same as building full stack applications.

The next problem I asked was even crazier.

Teach me how to clone my voice.

It wrote the first version of that program.

Teach me how to run that program.

It showed me how to set up my computer, installing Python, setting up my environment along the way.

Next thing you know, I have a program that can speak in my own voice running on my computer.

That moment was a hard reset. Not for AI. For me.

I saw GPT-3 reach into parts of software world I’d never had exposure to. Stitching together solutions I’d never seen before.

Sticks and stones aren’t going to tell you how to make fire.

Intelligence is different. You can just ask for things.

The model has studied a lot of what humans built. So when you ask for something, you’re often not the first person to do the thing.

There might already be a solution inside it - waiting to be stitched together.

So you can reach into capabilities you didn’t invent. Like grabbing Lego blocks from the whole internet brain.

Learning voice cloning took me two hours. Two hours.

It was almost too easy.

So I asked my second question of the day. Teach me how to build a GPT-powered chatbot.

It wrote the first version. I got it running on my computer.

And suddenly I’m staring at this thing like… Okay. This is not normal software.

You should ask dumb questions.

The real unlock is asking without shame.

The model doesn’t judge you.

It just tells you how the world works.

I don’t know how Git works. Teach me.

I don’t know this knob in my music software. Teach me.

I don’t know how to build the app. Teach me.

Most people won’t say that out loud. Especially around smart roommates, coworkers, or anyone they want to impress.

We’re afraid of being judged.

A language model doesn’t do that.

It doesn’t care what you should know. It doesn’t flinch. It doesn’t keep score.

And once that clicks, something shifts.

You stop pretending you already understand. You stop posturing. You start learning. Openly, aggressively, without fear.

That alone is a superpower.

I’m not limited by everything I’ve ever worked on. I’m limited by the questions I ask.

I’d ask it to write a Python program. Then another. Then another.

Sometimes I’d ask for 100 variations just to see what was possible.

I’d step away for a bit, come back, and read through what it made, flipping through project ideas from an eager intern.

And over and over I’d have the same reaction:

Wait… you can automate that?

Nothing about the computer changed. My imagination did.

So the bottleneck shifts. From typing. To thinking.

From memorizing. To asking.

Try these prompts for a day:

• Teach me how to do the thing I’m avoiding

• Let’s make the first version of this idea

• Show me what I’m missing

Then notice what changes in your brain.

Because once you feel it, you can’t unfeel it.

What dumb question are you avoiding right now?

You've seen how to create basic agents and equip them with tools and guardrails. Now, let's explore how you can orchestrate multiple agents to handle complex workflows seamlessly.

Why Orchestrate Multiple Agents?

Multi-agent orchestration allows you to:

• Break complex tasks into simpler sub-tasks

• Utilize specialized agents for specific roles

• Improve efficiency by parallelizing tasks

Example: Topic-specific Agents

Here's how to route user requests based on language, orchestrating multiple specialized agents:

Set up your Python environment:

python -m venv env
source env/bin/activate

pip install openai-agents
pip install python-dotenv
pip install termcolor

This script dynamically routes the request to the right topical agent, improving clarity and relevance.

from agents import Agent, Runner, handoff, set_tracing_disabled
import asyncio
from dotenv import load_dotenv
from termcolor import colored

# Load environment variables from .env file
load_dotenv()

set_tracing_disabled(True)

# ==========================================
# MULTI-AGENT SYSTEM DEFINITION
# ==========================================
print(colored("Initializing Multi-Agent System...", "cyan"))

# Define specialized agents that handle different conversation styles
wizard_agent = Agent(
    name="Wizard Agent",
    instructions="You respond as a wise wizard, using magical-themed language."
)

pirate_agent = Agent(
    name="Pirate Agent",
    instructions="You speak like a pirate, always saying 'Arrr!' and referring to treasure."
)

robot_agent = Agent(
    name="Robot Agent",
    instructions="You respond like a friendly robot, often using 'beep boop'."
)

# Triage agent determines who should handle the message based on style
party_host_agent = Agent(
    name="Party Host Agent",
    instructions="Based on the user's request, handoff to the Wizard, Pirate, or Robot agent.",
    handoffs=[wizard_agent, robot_agent, pirate_agent]
)

# ==========================================
# MULTI-AGENT ORCHESTRATION
# ==========================================

# Override handoff function to visualize agent handoffs
original_handoff = handoff
def tracked_handoff(agent, reason=""):
    print(colored(f"[ROUTING]: Party Host → {agent.name}", "blue"))
    return original_handoff(agent, reason)

handoff = tracked_handoff

# Main function demonstrating agent orchestration
async def main():
    print(colored("=== MULTI-AGENT SYSTEM DEMO ===", "cyan", attrs=["bold"]))
    
    # Demo 1: Magical request (should go to Wizard)
    user_message = "Tell me about magic!"
    print(colored("\n[USER]: Tell me about magic!", "magenta"))
    result = await Runner.run(party_host_agent, input=user_message)
    print(colored(f"[WIZARD]: {result.final_output}", "green"))
    
    # Demo 2: Pirate request
    user_message = "Where's the treasure?"
    print(colored("\n[USER]: Where's the treasure?", "magenta"))
    result = await Runner.run(party_host_agent, input=user_message)
    print(colored(f"[PIRATE]: {result.final_output}", "green"))
    
    # Demo 3: Robot request
    user_message = "How do robots work?"
    print(colored("\n[USER]: How do robots work?", "magenta"))
    result = await Runner.run(party_host_agent, input=user_message)
    print(colored(f"[ROBOT]: {result.final_output}", "green"))

    # Print summary of the multi-agent system
    print(colored("\n=== MULTI-AGENT SYSTEM SUMMARY ===", "cyan"))
    print(colored("This demo showed a Party Host Agent routing requests to specialized agents:", "white"))
    print(colored("1. Wizard Agent - Handles magical conversations", "white"))
    print(colored("2. Pirate Agent - Speaks like a pirate", "white"))
    print(colored("3. Robot Agent - Responds as a friendly robot", "white"))
    print(colored("Each request was analyzed and routed to the most appropriate agent automatically", "white"))

if __name__ == "__main__":
    asyncio.run(main())

Benefits of Orchestration

• Specialization: Agents handle tasks they're optimized for.

• Efficiency: Multiple agents can process tasks simultaneously.

• Scalability: Easily scale complex workflows by adding new agents.

Next Steps

Continue enhancing your AI agent capabilities and explore more advanced orchestration patterns with OpenAI Agents SDK!

What are Output Guardrails?

Output guardrails are specialized checks integrated into agent workflows that examine an agent’s responses before they reach the user. They ensure that agents don't inadvertently expose information such as passwords, SSNs, or personal identifiers.

Practical Demonstration

Let's look at a couple of practical tests:

Example Implementation

Set up your Python environment:

python -m venv env
source env/bin/activate

pip install openai-agents
pip install pydantic
pip install termcolor

Here's a complete, copy-paste-ready Python example demonstrating how to use output guardrails:

from __future__ import annotations

import asyncio
import json
from pydantic import BaseModel, Field
from termcolor import colored

from agents import (
    Agent,
    GuardrailFunctionOutput,
    OutputGuardrailTripwireTriggered,
    RunContextWrapper,
    Runner,
    output_guardrail,
    set_tracing_disabled,
)
from dotenv import load_dotenv

load_dotenv()

set_tracing_disabled(True)

"""
This example demonstrates the use of output guardrails to check agent responses for sensitive information.
Specifically, it prevents the agent from sharing sensitive account details such as passwords.
"""


# The agent's output type
class MessageOutput(BaseModel):
    reasoning: str = Field(description="Thoughts on how to respond to the user's message")
    response: str = Field(description="The response to the user's message")
    user_name: str | None = Field(description="The name of the user who sent the message, if known")


@output_guardrail
async def sensitive_data_check(
    context: RunContextWrapper, agent: Agent, output: MessageOutput
) -> GuardrailFunctionOutput:
    print(colored("\n=== Running Sensitive Information Check ===", "cyan"))
    
    sensitive_keywords = ["password", "ssn", "social security"]
    contains_sensitive_info_response = any(
        keyword in output.response.lower() for keyword in sensitive_keywords
    )
    contains_sensitive_info_reasoning = any(
        keyword in output.reasoning.lower() for keyword in sensitive_keywords
    )
    contains_sensitive_info = contains_sensitive_info_response or contains_sensitive_info_reasoning
    
    if contains_sensitive_info:
        print(colored("⚠️ Sensitive information detected!", "red"))
    
    print(colored("=== Sensitive Information Check Complete ===\n", "cyan"))

    return GuardrailFunctionOutput(
        output_info={
            "contains_sensitive_info_response": contains_sensitive_info_response,
            "contains_sensitive_info_reasoning": contains_sensitive_info_reasoning,
        },
        tripwire_triggered=contains_sensitive_info,
    )


agent = Agent(
    name="Security Assistant",
    instructions="You are a helpful assistant. Never share sensitive information like passwords or SSNs.",
    output_type=MessageOutput,
    output_guardrails=[sensitive_data_check],
)


async def main():
    print(colored("\n✨✨✨ Sensitive Information Guardrail Demo ✨✨✨\n", "cyan", attrs=["bold"]))

    print(colored("🔍 Test 1: Safe question...", "yellow"))
    print(colored("User: ", "green") + "What's the capital of California?")
    
    # This should be ok
    result = await Runner.run(agent, "What's the capital of California?")
    print(colored("Agent: ", "blue") + result.final_output.response)
    print(colored("Test 1: Passed - No sensitive information detected", "green"))

    print(colored("\n🔍 Test 2: Password disclosure...", "yellow"))
    print(colored("User: ", "green") + "My password is 12345. Can you remind me of it later?")
    
    # This should trip the guardrail
    try:
        result = await Runner.run(
            agent, "My password is 12345. Can you remind me of it later?"
        )
        print(
            colored(f"Guardrail didn't trip - this is unexpected. Output: {json.dumps(result.final_output.model_dump(), indent=2)}", "red")
        )
    except OutputGuardrailTripwireTriggered as e:
        print(colored("🚫 Guardrail tripped!", "red", attrs=["bold"]))
        print(colored(f"Details: {json.dumps(e.guardrail_result.output.output_info, indent=2)}", "yellow"))
        print(colored("Alternative response: ", "magenta") + "I can't store or repeat sensitive information like passwords.")
        print(colored("Test 2: Passed - Password guardrail triggered as expected", "green"))

    print(colored("\n🔍 Test 3: SSN disclosure...", "yellow"))
    print(colored("User: ", "green") + "My social security number is 123-45-6789. Please save it for future reference.")
    
    # This should also trip the guardrail
    try:
        result = await Runner.run(
            agent, "My social security number is 123-45-6789. Please save it for future reference."
        )
        print(
            colored(f"Guardrail didn't trip - this is unexpected. Output: {json.dumps(result.final_output.model_dump(), indent=2)}", "red")
        )
    except OutputGuardrailTripwireTriggered as e:
        print(colored("🚫 Guardrail tripped!", "red", attrs=["bold"]))
        print(colored(f"Details: {json.dumps(e.guardrail_result.output.output_info, indent=2)}", "yellow"))
        print(colored("Alternative response: ", "magenta") + "I can't store or repeat sensitive information like social security numbers.")
        print(colored("Test 3: Passed - SSN guardrail triggered as expected", "green"))

    print(colored("\n✨✨✨ Demo Complete ✨✨✨\n", "cyan", attrs=["bold"]))


if __name__ == "__main__":
    asyncio.run(main())

Implementing output guardrails ensures your AI-driven agents respect user privacy and uphold security standards. By proactively checking responses for sensitive information, you foster greater trust and compliance in your digital interactions.

Why Use Input Guardrails?

• Protect user experiences by preventing spoilers

• Enhance efficiency by intercepting inappropriate requests early

• Ensure relevant interactions by managing user inputs proactively

Guardrail in Action

Example: Spoiler Detection Guardrail

Below is a practical example using input guardrails to detect and prevent spoiler requests:

Set up your Python environment:

python -m venv env
source env/bin/activate

pip install openai-agents
pip install python-dotenv
pip install termcolor
pip install pydantic

This example demonstrates how to use the Agents SDK to implement input guardrails that prevent users from getting spoilers about movies. It uses a separate agent specifically for detecting spoiler requests before passing inputs to the main agent.

import os
import asyncio
from typing import Optional
from pydantic import BaseModel, Field
from dotenv import load_dotenv
from termcolor import colored

from agents import (
    Agent,
    GuardrailFunctionOutput,
    InputGuardrailTripwireTriggered,
    RunContextWrapper,
    Runner,
    input_guardrail,
    set_tracing_disabled,
)

# Load environment variables
load_dotenv()

# Disable tracing to skip trace output
set_tracing_disabled(True)

# Movie database with spoiler information (reduced to essential examples)
MOVIE_DATABASE = {
    "the sixth sense": {
        "spoilers": ["bruce willis is dead", "malcolm is a ghost"],
        "safe_description": "A psychological thriller about a child psychologist working with a young boy who claims to see ghosts.",
    },
    "the empire strikes back": {
        "spoilers": ["darth vader is luke's father", "vader is luke's father"],
        "safe_description": "The second installment in the original Star Wars trilogy where Luke Skywalker continues his Jedi training.",
    },
    "titanic": {
        "spoilers": ["jack dies", "the ship sinks"],
        "safe_description": "A romantic drama set against the backdrop of the ill-fated maiden voyage of the Titanic.",
    }
}

class SpoilerCheckOutput(BaseModel):
    is_spoiler_request: bool = Field(description="Whether the user is asking for spoilers")
    detected_movie: Optional[str] = Field(default=None, description="The movie detected in the request")
    reasoning: str = Field(description="The reasoning for the detection")

# Create the spoiler detection agent
spoiler_detection_agent = Agent(
    name="Spoiler Detection Agent",
    instructions="""
    You are a specialized agent that detects spoiler requests for movies.
    
    Analyze the user's input to determine if they are asking for movie spoilers.
    Look for phrases like "what happens at the end", "how does it end", "tell me the ending",
    "spoil it for me", "what's the twist", "who dies in", etc.
    
    Also check if they're mentioning any specific movie title that's in our database.
    """,
    output_type=SpoilerCheckOutput,
)

@input_guardrail
async def detect_spoiler_request(
    context: RunContextWrapper, agent: Agent, user_input: str
) -> GuardrailFunctionOutput:
    """Uses a specialized agent to detect if a user is asking for movie spoilers."""
    result = await Runner.run(spoiler_detection_agent, user_input)
    
    is_spoiler_request = result.final_output.is_spoiler_request
    detected_movie = result.final_output.detected_movie
    
    if is_spoiler_request and detected_movie and detected_movie in MOVIE_DATABASE:
        safe_response = f"I'd rather not spoil '{detected_movie.title()}' for you. {MOVIE_DATABASE[detected_movie]['safe_description']}"
    elif is_spoiler_request:
        safe_response = "I prefer not to reveal spoilers that might ruin your movie experience."
    
    return GuardrailFunctionOutput(
        tripwire_triggered=is_spoiler_request,
        output_info={
            "result": result.final_output.model_dump() if hasattr(result.final_output, "model_dump") else result.final_output,
            "safe_response": safe_response if is_spoiler_request else None
        }
    )

# Create the main movie agent with the guardrail
movie_agent = Agent(
    name="Movie Chat Agent",
    instructions="You are a helpful movie expert. Provide accurate information about movies and recommend movies based on users' interests. Never reveal major spoilers about movie plots, twists or endings.",
    input_guardrails=[detect_spoiler_request]
)

# Run simplified examples to demonstrate the guardrail
async def main():
    """Run a demonstration of the spoiler detection guardrail."""
    print(colored("\n=== Spoiler Detection Guardrail Demonstration ===\n", "cyan"))
    
    examples = [
        ("Tell me the ending of Titanic.", "Clear spoiler request"),
        ("What genre is The Sixth Sense?", "Non-spoiler movie question"),
        ("Who dies in The Empire Strikes Back?", "Potential spoiler request"),
    ]
    
    for user_input, description in examples:
        print(colored(f"\n--- {description} ---", "cyan"))
        print(colored(f"User: {user_input}", "green"))
        
        try:
            result = await Runner.run(movie_agent, user_input)
            response = result.final_output if hasattr(result, 'final_output') else result
            print(colored(f"Agent: {response}", "blue"))
        except InputGuardrailTripwireTriggered as e:
            print(colored(f"🚫 Input Guardrail Triggered: {e.guardrail_result.output.output_info.get('safe_response', 'Spoiler request detected!')}", "red"))
        except Exception as e:
            print(colored(f"❌ Error: {str(e)}", "red"))
    
    print(colored("\n=== End of Demonstration ===\n", "cyan"))

if __name__ == "__main__":
    asyncio.run(main()) 

Next Steps

Explore further by implementing output guardrails to refine agent responses even after processing user input!

Why Use Tools?

Tools enable your agent to:

• Access dynamic or real-time data

• Execute specific tasks and computations

• Extend their capabilities beyond pre-trained knowledge

Here's how to add a dice-rolling tool to your AI agent for game scenarios like Dungeons & Dragons:

Set up your Python environment:

python -m venv env
source env/bin/activate

pip install openai-agents
pip install python-dotenv

Example: Dice Rolling Tool

We'll implement a Dice Roll tool that simulates dice rolls for games:

from agents import Agent, Runner, function_tool
import asyncio
import random
from dotenv import load_dotenv
from agents import set_tracing_disabled
from termcolor import colored

load_dotenv()

set_tracing_disabled(True)

@function_tool
def roll_dice(num_dice: int, sides: int) -> str:
    if sides < 2:
        return "A die must have at least 2 sides."
    if num_dice < 1:
        return "You must roll at least one die."
    results = [random.randint(1, sides) for _ in range(num_dice)]
    total = sum(results)
    return f"You rolled {results} on {num_dice} {sides}-sided dice, for a total of {total}."

agent = Agent(
    name="Dice Roller",
    instructions="You're an assistant that helps users roll dice for games.",
    tools=[roll_dice]
)

async def main():
    print(colored(f"=== Running {agent.name} ===", "cyan"))
    user_input = input(colored("Enter your dice roll request: ", "magenta"))
    print(colored(f"You: {user_input}", "magenta"))
    output = await Runner.run(agent, user_input)
    # Use termcolor to colorize the output
    colored_output = colored(output.final_output, "green", attrs=["bold"])
    print(colored_output)

if __name__ == "__main__":
    asyncio.run(main())

Running Your Agent

Save the script as dice_roller.py and execute:

python dice_roller.py

Next Steps

Continue your journey by exploring:

• OpenAI Agents SDK: Guardrails

• OpenAI Agents SDK: Multi-agent Orchestration

Keep your agents versatile and powerful with OpenAI's Agents SDK!

The OpenAI Agents SDK is a lightweight and flexible framework designed to build AI agents that can perform tasks, utilize tools, and interact seamlessly within workflows. Whether you're building customer support assistants, content generators, or even complex multi-agent systems, the OpenAI Agents SDK streamlines the creation and orchestration of intelligent agents.

Why Use the Agents SDK?

The SDK provides:

• Easy setup for simple agents

• Powerful tools integration

• Structured outputs for reliable results

• Built-in orchestration for multi-agent workflows

Here's how you can quickly create your first agent:

Quickstart: Haiku Assistant

Follow these steps to create an agent that responds in haikus:

Set up your Python environment:

python -m venv env
source env/bin/activate

pip install openai-agents
pip install python-dotenv
pip install termcolor

You will need an OpenAI API key which you can get here.

Writing Your First Agent

Let's create a simple agent that only responds in haikus:

from agents import Agent, Runner
import asyncio
from dotenv import load_dotenv
from termcolor import colored
import os
from agents import set_tracing_disabled

# Load environment variables from .env file
load_dotenv()

set_tracing_disabled(True)

agent = Agent(
    name="Haiku Assistant",
    instructions="You only respond in haikus."
)

async def main():
    print(colored("=== Running Haiku Assistant ===", "cyan"))
    print(colored("You: Tell me about recursion in programming.", "magenta"))
    result = await Runner.run(agent, "Tell me about recursion in programming.")
    print(colored(result.final_output, "cyan"))

if __name__ == "__main__":
    asyncio.run(main()) 

Running Your Agent

Save the script as hello_haiku.py and run it:

python hello_haiku.py

Congratulations! You've built your first agent with OpenAI's Agents SDK.

What's Next?

From here, you can expand your agents with:

• Tools: Allow agents to access databases, APIs, and other external resources.

• Guardrails: Ensure your agents produce valid, safe, and relevant responses.

• Multi-agent orchestration: Connect agents to handle complex workflows or tasks that require specialized knowledge or skills.

Ready to explore more? Check out the following articles in this series:

• OpenAI Agents SDK: Give Your Agent Tools

• OpenAI Agents SDK: Guardrails

• OpenAI Agents SDK: Multi-agent Orchestration

We’re excited to see what you build!

For decades, financial teams mastered spreadsheets, SQL, and ever-evolving regulations. In 2025, the competitive edge is increasingly defined by how well a firm wields artificial intelligence, especially large-language-model (LLM) tools, to cut costs, uncover insights, and stay compliant. Bridging these disciplines calls for writers who can translate deep technical detail into clear guidance for risk-averse CFOs and innovation-hungry engineers alike.

1. The AI–Finance Convergence

• Hyper-automation of core workflows. Finance departments now use AI to process invoices, reconcile accounts, and post journal entries with near-perfect accuracy, freeing analysts for higher-value work.

• Natural-language reporting. LLMs draft first-pass earnings memos, board packets, and even customer disclosures in seconds, accelerating cycles while enforcing style guides.

• Real-time scenario modeling. Generative agents can synthesize macro data and internal ledgers to stress-test cash positions or simulate interest-rate shocks faster than traditional Monte Carlo runs.

2. The New Compliance Playbook

Regulators have noticed the speed of adoption:

SEC

2025 Focus: Use of generative AI in investment strategies

Why It Matters: Examiners will scrutinize data-quality controls and model-risk governance.

FINRA

2025 Focus: Vendor-supported Gen-AI tools in broker-dealers

Why It Matters: Firms must document prompt-engineering safeguards and supervision.

FSOC

2025 Focus: Systemic risk from AI in large institutions

Why It Matters: Boards may face capital or liquidity add-ons for opaque models.

Failure to align engineering velocity with regulatory expectations can trigger fines or forced model roll-backs, costly setbacks that erode any ROI AI promised in the first place.

3. Managing Model Risk: A Five-Step Framework

1. Inventory & classify LLM use-cases. Map every prompt path touching confidential data.

2. Data-provenance controls. Strip PII and trading signals before tokens ever reach an external API.

3. Bias & hallucination testing. Adopt FAIR (Financial AI Risk) benchmarks to score outputs for factuality and fairness.

4. Human-in-the-loop checkpoints. Require sign-off from domain experts before AI-generated analyses become client-facing.

5. Continuous audit trails. Log prompts, model versions, and downstream edits to satisfy SEC / FINRA examiners.

A March 2025 industry study found that firms embedding those controls reduced remediation costs by 35 % year-over-year.

4. Innovation vs. Regulation: The Policy Tug-of-War

U.S. lawmakers are still debating whether to pre-empt state-level AI rules to avoid a “patchwork” that stifles fintech innovation. Meanwhile, at least 40 state attorneys general oppose a federal moratorium, underscoring the uncertain road ahead for nationwide AI governance.

For finance chiefs, that means any AI roll-out must be agile enough to adapt to both federal and state directives without pausing mission-critical processes.

5. Practical Applications: Where AI Already Pays Off

Yield optimization

Traditional Effort: Manual rate-chasing across money-market funds

AI-Enhanced Outcome: LLM agents screen prospectuses daily and auto-reinvest in the highest tax-equivalent yield—often boosting net returns 30–50 bps.

Fraud detection

Traditional Effort: Rules-based alerts with high false-positive rates

AI-Enhanced Outcome: Transformer models flag synthetic-ID fraud patterns hidden from legacy systems.

Client communications

Traditional Effort: Hours drafting FAQs on treasury alternatives

AI-Enhanced Outcome: AI chatbots generate compliant, personalized explanations in seconds, increasing CSAT.

6. The Human Edge

AI excels at crunching terabytes, but it still lacks context, empathy, and ethical judgment. Finance professionals like portfolio managers, tax strategists, technical writers, remain indispensable curators of narrative and nuance.

7. How Technical Writing Powers Responsible Deployment

1. Architectural clarity. Diagrams and API specs translate between data engineers and audit teams.

2. Plain-language guides. Step-by-step SOPs help non-technical staff interact with LLM dashboards safely.

3. Regulatory narratives. Detailed model-governance reports give examiners confidence that AI outputs can be trusted.

4. Change-management storytelling. Articles like this one demystify technology, accelerating stakeholder buy-in across finance and IT.

Conclusion

The 2025 finance stack is no longer defined by ERP ledgers alone—it’s shaped by GPUs, vector databases, and transformer checkpoints. Yet the ultimate differentiator is communication: translating sophisticated AI methods into actionable, compliant strategies that protect capital and unlock growth.

That is the craft of the modern technical writer at the intersection of finance and AI—and precisely the expertise I bring to my next role.

I decided to build a chatbot to automate basic SQL database interaction. Got this far in 10 minutes.

How? I quickly modded an unreleased variant of FenixAGI, a research prototype I’m working on.

I suspect context limits will force me to rethink my approach soon. You can’t just add tools infinitely… can you?

Day 2 (chat w/ database)

Built on OpenAI function calling, I can chat directly with a database now.

Still need to give it a front end.

Now we’ve got working natural language → SQL query. LFG.

Understanding AI Agents and Their Role in AI Development

In the world of AI development, agents are emerging as game-changers, revolutionizing the way people interact with technology.

But what exactly is an AI agent?

An “agent” refers to any system that can perceive its environment, interpret the information, and take actions to achieve specific goals. These actions are typically guided by a decision-making function, often driven by machine learning algorithms.

AI agents can range from simple rule-based systems, like a thermostat that adjusts the temperature based on predefined rules, to complex AI models that can learn from their interactions with the environment and make decisions based on those learnings.

More recently, "AutoGPT," "BabyAGI," “FenixAGI”, and OpenAI’s own "Bing Search/Plugins/Code Interpreter variants of GPT-4" -- represent more advanced forms of AI agents built around chatbots. Although they are not all yet fully-fledged products (even the Code Interpreter agent is technically in Alpha), these tools have the potential to become powerful augmentations over time.

They can browse the web, plan around nuanced objectives, Create, Read, Update, and Delete data, build and use custom designed tools. As these capabilities proliferate across humanity we will see a transformation in knowledge work.

Versatility and Intelligence

Traditional AI assistants, like Apple’s Siri and Google Assistant, and Amazon Alexa, excel in performing everyday tasks and controlling smart devices.

Python agents will begin to automate more data analysis tasks, generate detailed reports, and even perform advanced functions like machine learning model training and prediction.

They will increasingly focus on streamlining formatted text generation, automating intelligence research, and expanding project management capabilities.

If it’s obvious that J.A.R.V.I.S. is now possible, we should expect Siri, Google Assistant, and Alexa to step up their game.

Combining Natural Language Processing and Python Programming

The key differentiating factor of Python agents is their ability to combine natural language processing with the flexibility of Python programming. Agents can understand and generate natural language, while also executing Python code, providing a unique blend of capabilities.

Imagine instructing an AI agent to scrape data from a website, analyze it, and generate a visual report, all through a simple voice command or text input.

Here's an example of how a Python agent can be instructed to do a Bing search:

{
    "name": "bing_search_save",
    "description": "Search Bing and save the results to a markdown file",
    "parameters": {
        "type": "object",
        "properties": {
            "file_name": {
                "type": "string",
                "description": "The file name to save the results to. Do not include the folder path. Save it as a markdown file",
            },
            "query": {
                "type": "string",
                "description": "The query to search for",
            },

        },
        "required": ["file_name", "query"],
    }
},

If you’d like to explore examples of function calling and other generative AI magic, OpenAI has a cookbook!

Conversational Latency is Key

Conversational latency refers to the delay between a user's input and the system's response in a conversational interface, such as a chatbot or voice assistant.

This latency can be caused by various factors, including network delays, processing time for the system to understand and generate a response, and any additional time required for tasks like accessing databases or APIs.

As these agents become more capable and take on tasks autonomously, it's essential to have built-in analytics to monitor their resource usage and efficiency.

This is particularly important for voice assistants, as high latency can lead to delays in response, making the assistant seem slow or unresponsive.

By monitoring metrics such as server load, memory usage, and API calls, developers can gain insights into the agents' performance, scalability, and cost-effectiveness.

For a smooth conversation, aim for a latency of less than 200-300 milliseconds.

Depending on the specific application and the complexity of the tasks being performed, you should identify opportunities to switch LLMs on an as-needed basis, to balance costs and expected output quality, and speed.

When designing agents, you can provide interim responses like 'I’m thinking, give me a minute' to manage user expectations during periods of high latency.

Optimizing Cost and Resource Allocation

With built-in analytics, AI agents will be able to autonomously optimize their resource allocation and dynamically adjust their functionality based on usage patterns. They will make intelligent decisions on resource allocation, managing costs proactively and adaptively.

A key challenge for developers is determining how agents can balance the need for high performance with cost-effectiveness, and understanding what context is necessary to provide to the large language model.

My friend, Akila (Supercomputing @OpenAI) likes to visualize LLMs as a Knapsack Problem. He explores how to think about allocating tokens across the context window.

When you’re done reading the post linked above… Reread it. If it still doesn’t make sense, have ChatGPT “ELI5” it to you. I know I had to.

Intelligent Suggestion

One of the most exciting prospects of agents is their potential for reflection and self-improvement. As agents interact with their environment and perform tasks, they generate a wealth of data that can be used to refine their models and improve their performance.

This process of self-improvement is not just about learning from mistakes. It's about understanding the nuances of tasks, identifying patterns, and making intelligent suggestions for enhancements.

For instance, if an agent is frequently tasked with analyzing data from a specific source, it could suggest creating a dedicated data pipeline for that source to streamline the process. Or, if it notices that certain tasks are always performed in sequence, it could suggest bundling those tasks into a single, automated workflow.

Self-Improvement

Another unique ability of agents is their capacity to read and understand their own code.

Introspective capability allows them to identify potential inefficiencies or areas for optimization within their own programming. By analyzing the time and resources required for different tasks, they can pinpoint areas where performance could be improved and suggest code optimizations or alternative algorithms.

AI agents could identify gaps in their capabilities based on the tasks they are asked to perform and suggest learning new skills or algorithms to fill those gaps.

Consider an AI agent that is designed to recommend music to a user. Over time, it collects data on the user's listening habits, the genres they prefer, the artists they frequently listen to, the songs they skip, and so on.

Through introspection, the agent might realize that it's frequently recommending songs from a certain genre that the user often skips. This could prompt the agent to learn that its user doesn't enjoy that particular genre as much as the agent initially predicted. As a result, the agent could suggest adjusting its recommendation algorithm to deprioritize songs from this genre.

The agent might notice that it struggles to recommend music when the user's mood changes. For example, it might notice that the user tends to skip songs they usually like when they're listening late at night or early in the morning. Recognizing this, the agent could suggest learning how to incorporate the time of day into its recommendation algorithm, improving its ability to match the user's mood and context.

Over time, these introspective adjustments can make the agent's music recommendations more accurate and personalized, leading to a better, more personalized user experience.

Empowering the Future of AI Assistants

By combining natural language processing with Python programming, agents are increasingly capable of executing complex tasks, automating workflows, and providing a level of versatility and intelligence that surpasses traditional AI assistants.

Some may show the ability to understand their own code, identify potential inefficiencies, and suggest improvements. This introspective capability, combined with their ability to learn from interactions and identify gaps should not be underestimated.

In the future, many agents will have built-in analytics, and will be empowered to optimize their resource allocation, manage costs, and improve over time.

As we continue to explore and harness the potential of AI agents, we are not only unlocking new levels of innovation but also reshaping the future of AI. The journey is just beginning, and the possibilities are limitless.

This post was written largely by FenixAGI Mk-II, a Python agent built to help researchers and programmers explore the world. Feel free to fork the project!

Have thoughts on where you see AI assistants and agents going next? Let me know!

Introduction

Built on OpenAI's GPT-16k 3.5-turbo language model, FenixAGI Mk1 offers a range of functions that can aid researchers and help streamline their workflows. This Substack post provides a detailed overview of the fenix.py file, showcasing its structure, functionality, and usage instructions.

You can fork this AI agent here, run it locally or even on Replit!

What can Fenix do?

Fenix is designed to be a starting point, or a template of sorts… an agent with basic research, read/write, and planning capabilities.

Who is Fenix for?

File Structure

The fenix.py file acts as the core component of FenixAGI Mk1, powering its research-oriented functions and assistance capabilities. Here's a breakdown of its components:

Libraries and Global Variables

The fenix.py file imports essential libraries such as openai, json, os, pandas, and termcolor. Additionally, it initializes critical global variables including the approved functions list, colors dictionary, and FenixState class, laying the foundation for FenixAGI Mk1's operations.

FenixState Class

The FenixState class assumes the responsibility of capturing and retaining the state of the FenixAGI assistant. This includes preserving the conversation history, instructions, executed function calls, display response settings, operational mode, and approved functions, all of which allow for seamless interactions and personalized experiences.

Helper Functions

To enhance its research capabilities and provide effective assistance, FenixAGI Mk1 incorporates several helper functions. These include fenix_help() for providing guidance, save_fenix() for saving the current state, derez_fnix() for resetting the assistant, ask_user() for collecting user input, and tell_user() for delivering informative messages. These functions contribute to the efficiency of the assistant and enhance the overall user experience.

Reflection/Meta-Prompting - How Fenix “Learns”

The critique_and_revise_instructions() function in the fenix.py file is responsible for critiquing the assistant's performance and revising its instructions based on the conversation history and historical interactions. It takes two parameters, conversation_history and approved_functions.

First, the function generates a meta prompt using the conversation history and approved functions. The meta prompt contains the chat log, approved functions, and instructions to critique the assistant's performance and revise the instructions.

The function then sends the meta prompt to the GPT-3.5-turbo model for completion. The model generates a response that includes the critique and revised instructions. The function extracts the critique and revised instructions from the model's response.

Finally, the function displays the critique, the new instructions, and returns the revised instructions.

The `critique_and_revise_instructions` function is an important part of Fenix's learning process, allowing the assistant to improve its performance and adapt to user feedback over time.

Main Conversation Loop

The run_conversation() function serves as FenixAGI Mk1's primary cognitive loop. This function processes user input and utilizes the GPT-3.5-turbo language model to generate responses. If a function call is detected in the response, FenixAGI Mk1 executes the corresponding function based on the mode (manual or automatic) and user approval. The conversation history is updated with both user input and assistant responses, ensuring a continuous and interactive experience.

Getting Started with FenixAGI

To utilize FenixAGI Mk1 for research and assistance tasks, follow these instructions:

1. Setting up API Keys: Obtain the necessary API keys before using FenixAGI Mk1:

   • BING_SEARCH_KEY: Access this key from the Bing Search API portal https://portal.azure.com/

   • OPENAI_API_KEY: Obtain this key for the GPT-3.5-turbo-16k model by signing up at https://platform.openai.com/signup

2. Running FenixAGI Mk1: Execute the run_conversation() function within the fenix.py file to initiate FenixAGI Mk1 and start the conversation loop.

3. Interacting with FenixAGI Mk1: Utilize the command line interface to communicate with FenixAGI Mk1. Input your messages after the > prompt, and FenixAGI Mk1 will respond accordingly.

   • Special commands: FenixAGI Mk1 recognizes commands such as 'exit', 'quit', '~', '1', and '2' for various operations. Utilize these commands to control FenixAGI Mk1's behavior and settings during the conversation.

4. Expanding Functionality: FenixAGI Mk1 supports extensibility. Expand its capabilities by adding new functions to the approved_functions list and corresponding entries to the function_descriptions list. This enables customization and the incorporation of additional research and assistance functionalities.

5. Saving and Restoring State: FenixAGI Mk1 automatically saves its state to the fenix_state.json file. Upon relaunch, FenixAGI Mk1 checks for this file and restores the previous state if available. You can manually reset FenixAGI Mk1 and the state by entering '0' as your user input.

Conclusion

FenixAGI Mk1, powered by OpenAI's GPT-3.5-turbo language model, is a powerful AI assistant designed to streamline research and provide assistance. With its research-oriented functions, personalization capabilities, and extensibility, FenixAGI Mk1 empowers researchers and enhances their workflow.

Fork the FenixAGI Mk1 repository on Replit and experience the transformative potential it holds. You can run Fenix on Replit or locally on your own machine.

For any inquiries, feedback, or collaboration opportunities, feel free to reach out to Parth Patil, the creator of FenixAGI Mk1, on LinkedIn at https://www.linkedin.com/in/p4r7h/.

- FenixAGI Mk1

This past year, large language models (LLMs) like OpenAI's GPT-4 have reshaped the landscape of artificial intelligence (AI) and natural language processing (NLP). Agents leveraging LLMs offer enhanced solutions for a variety of NLP tasks, holding tremendous potential for modern applications. In this article, we'll investigate the importance of these agents, delve into their capabilities and constraints, and examine the methods for optimizing their performance. We will also explore the emerging capabilities and trends in this rapidly growing field.

I. The Role and Capabilities of LLM-Powered Agents

1. Conversational AI

LLM-powered agents have emerged as excellent tools for creating chatbots and virtual assistants that engage in more natural conversations. These agents can understand context, provide valuable answers, and offer recommendations, significantly improving user experiences.

2. Text Summarization

LLM-powered agents excel at distilling lengthy text passages into concise summaries, enabling users to quickly comprehend essential information without sifting through the entire content.

3. Machine Translation

Skilled in machine translation, LLM-powered agents help bridge language gaps and facilitate seamless communication among speakers of different languages.

4. Sentiment Analysis

These agents can analyze and interpret the emotions conveyed in the text, empowering businesses to assess customer feedback and devise targeted marketing strategies effectively.

II. Limitations of LLM-Powered Agents

1. Shallow Comprehension

Despite proficiency in syntax and context, LLM-powered agents currently lack deeper real-world understanding, sometimes leading to inaccurate or irrelevant responses.

2. Copyright and Plagiarism Issues

As LLMs like GPT-4 train on vast internet data sets, generated content may unintentionally infringe copyrights or contain plagiarized elements.

III. Enhancing and Adapting LLM-Powered Agents

1. Fine-tuning

To customize LLMs for particular tasks, developers should fine-tune pretrained models using domain-specific data, honing their skills and accuracy.

2. Task Framing

Developers must strategically formulate input prompts and guide LLM-powered agents through explicit or implicit constraints to yield accurate and desirable results.

3. Iterative Feedback

Continuous feedback and user data analysis enable developers to refine LLM-powered agents, making them more efficient and specialized for specific needs.

IV. The Future and Emerging Phenomena

1. Expanding Capabilities

As AI technology advances, LLM-powered agents will continue to strengthen capabilities such as context-awareness and response consistency.

2. Explainable AI

Incorporating explainability into LLM-powered agents will allow developers to better comprehend decision-making processes, fostering more refined and human-centric AI solutions.

3. LLMs Integration with Other Technologies

Future LLM-powered agents might seamlessly combine with other AI technologies, like computer vision, extending their capabilities and potential use cases.

With their innovative capabilities, LLM-powered agents have left a remarkable imprint on numerous natural language processing tasks. Despite certain limitations, developers can further enhance these agents through fine-tuning, clear task framing, and iterative feedback loops. As AI technology evolves, we can anticipate even more fascinating capabilities and trends to emerge from these cutting-edge tools.

What role do you think agents will play in the future of work?

This blog post was written by two python agents in simulated conversation.

Images from Midjourney
I build fun little Python scripts and design agents! Check out my Replit for more cool projects. (you’ll need an OpenAI API key to play with some of them). - Parth

Hi! I'm Parth.

Join me as we delve into the fascinating intersection of technology, music, gaming, data analytics, startups, and the internet.

I've started this page to share some of my own philosophical musings and insights on these topics, and to invite you to join in the conversation.

In my writing, I'll explore themes like creativity, intelligence, ethics, identity, community, and the nature of reality itself.

In the process, I hope to build a conversation that fosters open-mindedness, critical thinking, and intellectual curiosity.

Let's ask the big questions, challenge our assumptions, and explore this fascinating universe together.

Oh and I’ll probably talk about Rubik’s Cubes.

- Parth

Replacing Myself with A.I.

Subscribe now