AI isn't just responding anymore — it's acting. This week's post breaks down what makes Agentic AI so different and why it's changing everything from content creation to enterprise ops.

The shift from traditional AI to agentic systems represents the next major evolution in artificial intelligence. While traditional AI waits for your commands, agentic AI can set goals, make decisions, and take action on its own. This fundamental difference is reshaping how we build AI systems and what we can expect them to accomplish.

Read on to discover the key differences between these approaches and how you can start experimenting with agentic AI in your own projects.

TOP AI NEWS THIS WEEK

OpenAI Introduces "Autonomous Mode" for GPT-5

OpenAI has unveiled a new "Autonomous Mode" for GPT-5 that allows the model to operate with significantly greater independence. This feature enables GPT-5 to break down complex goals into manageable steps, execute those steps across multiple systems, and adapt its approach based on results—all with minimal human oversight. Early access partners report 70% reductions in human intervention for complex tasks like market research, content production, and data analysis. The feature includes configurable guardrails and detailed activity logs to address safety and transparency concerns.

Google DeepMind Launches AgentSphere for Multi-Agent Collaboration

Google DeepMind has released AgentSphere, an open-source framework for developing and deploying collaborative AI agent systems. The platform enables multiple specialized AI agents to work together on complex tasks, with built-in mechanisms for coordination, conflict resolution, and collective learning. AgentSphere includes pre-built agents for common functions like research, writing, coding, and data analysis, along with tools for creating custom agents. The framework is designed to make agentic AI more accessible to developers without expertise in multi-agent systems.

Microsoft Integrates Agentic Capabilities Across Office 365

Microsoft has announced the integration of agentic AI capabilities across its Office 365 suite, moving beyond the current Copilot features. The new "Copilot Agents" can manage entire workflows spanning multiple applications, such as researching topics in Edge, creating presentations in PowerPoint, drafting documents in Word, and scheduling follow-ups in Outlook—all from a single instruction. The system maintains context across applications and can adapt to user feedback in real-time. Microsoft emphasizes that these agents are designed to augment human work rather than replace it, focusing on reducing administrative burden.

Anthropic Releases Claude 4 with Enhanced Agentic Capabilities

Anthropic has launched Claude 4, featuring significantly enhanced agentic capabilities compared to previous versions. The new model demonstrates improved planning abilities, better reasoning about constraints, and more effective tool use across diverse domains. Claude 4 can maintain goals over extended interactions, adapt strategies based on feedback, and coordinate multiple sub-tasks to achieve complex objectives. Anthropic has also introduced a new evaluation framework specifically designed to assess agentic capabilities, which they're releasing to help standardize benchmarks in this emerging field.

EU Proposes New Regulatory Framework for Autonomous AI Systems

The European Union has proposed a new regulatory framework specifically addressing autonomous AI systems with agentic capabilities. The framework extends the existing EU AI Act with additional requirements for systems that can act independently, including mandatory human oversight mechanisms, detailed logging of autonomous decisions, and regular audits of system behavior. The proposal also introduces a classification system for different levels of AI autonomy, with escalating requirements based on the degree of independence and potential impact. Industry stakeholders have until September to provide feedback before the framework moves to the next stage of the legislative process.

HIGHLIGHTS: Most Striking Differences Between Traditional and Agentic AI

1. From Reactive to Proactive

Traditional AI waits for your commands, like a sophisticated tool that needs an operator for every task. Agentic AI identifies opportunities and takes initiative without constant direction—it can spot a problem in your workflow and fix it before you even notice.

Why it matters: This shift fundamentally changes how we interact with AI. Instead of spending time managing AI tools, you can focus on higher-level strategy while agentic systems handle execution. For creators, this means AI that doesn't just help with requested tasks but proactively suggests new ideas, identifies content gaps, and even starts drafts based on your publishing calendar.

2. Handling Complex, Multi-Step Workflows

Traditional AI excels at discrete tasks but struggles with complex processes requiring coordination. Agentic AI manages end-to-end workflows across multiple systems, adapting to changing circumstances along the way.

Why it matters: This capability extends automation beyond simple tasks to complex workflows that previously required human coordination. For example, rather than using separate AI tools for research, writing, editing, and publishing, an agentic system can manage your entire content production pipeline—coordinating across platforms, handling exceptions, and ensuring consistency throughout.

3. Continuous Learning Without Retraining

Traditional AI improves through periodic retraining with new data, requiring human intervention to evolve. Agentic AI learns continuously from interactions and feedback, becoming more effective over time without explicit updates.

Why it matters: Your AI tools become increasingly personalized to your specific needs and preferences without constant configuration. They adapt to your feedback, learn from mistakes, and refine their understanding of your goals—creating a virtuous cycle of improvement that doesn't depend on the developer releasing new versions.

4. True Human-AI Collaboration

Traditional AI serves as a tool directed by humans, with clear boundaries between human and machine responsibilities. Agentic AI functions more as a partner, understanding intent, negotiating objectives, and collaborating toward shared goals.

Why it matters: This evolution transforms how we work with AI from tool usage to collaborative partnership. Agentic systems can understand the "why" behind requests, suggest alternative approaches when appropriate, and adapt their behavior based on your working style—creating a more natural and productive relationship that amplifies human creativity rather than just executing commands.

AI TUTORIAL: Getting Started with Agentic AI Using OpenAI Assistants API

What You'll Build:

A simple but powerful agentic AI system that can research topics, generate content, and manage your content calendar with minimal oversight.

Prerequisites:

• OpenAI API account (with access to Assistants API)

• Basic understanding of API usage

• Python installed on your computer

Step 1: Set Up Your Environment (5 minutes)

1. Create a new directory for your project:

bash

mkdir agentic-assistant
cd agentic-assistant

2. Create a virtual environment and activate it:

bash

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install required packages:

bash

pip install openai python-dotenv

4. Create a .env file to store your API key:

bash

touch .env

5. Add your OpenAI API key to the .env file:

OPENAI_API_KEY=your_api_key_here

Step 2: Create Your Agentic Assistant (10 minutes)

Create a file named create_assistant.py with the following code:

python

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Create an assistant
assistant = client.beta.assistants.create(
    name="Content Strategy Agent",
    instructions="""
    You are an agentic AI assistant specialized in content strategy and creation.
    
    Your capabilities include:
    1. Researching topics and identifying key insights
    2. Generating content outlines and drafts
    3. Managing content calendars and suggesting optimal posting schedules
    4. Adapting content for different platforms and audiences
    
    You should be proactive in your assistance, anticipating needs and suggesting improvements.
    When given a goal, break it down into manageable steps and execute them systematically.
    Maintain context across interactions and learn from feedback to improve your assistance.
    
    Always prioritize quality and strategic alignment over quantity.
    """,
    model="gpt-4-turbo",
    tools=[{"type": "retrieval"}]
)

# Print the assistant ID (save this for future use)
print(f"Assistant created with ID: {assistant.id}")

Run this script to create your assistant:

bash

python create_assistant.py

Save the assistant ID that's printed—you'll need it for the next step.

Step 3: Create a Thread for Ongoing Conversation (5 minutes)

Create a file named create_thread.py:

python

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Create a thread
thread = client.beta.threads.create()

# Print the thread ID (save this for future use)
print(f"Thread created with ID: {thread.id}")

Run this script to create a thread:

bash

python create_thread.py

Save the thread ID—you'll use it to maintain context across interactions.

Step 4: Interact with Your Agentic Assistant (10 minutes)

Create a file named interact.py:

python

import os
import time
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Replace with your actual IDs
ASSISTANT_ID = "your_assistant_id_here"
THREAD_ID = "your_thread_id_here"

def send_message(message_content):
    """Send a message to the assistant and get the response"""
    # Add the user message to the thread
    client.beta.threads.messages.create(
        thread_id=THREAD_ID,
        role="user",
        content=message_content
    )
    
    # Run the assistant on the thread
    run = client.beta.threads.runs.create(
        thread_id=THREAD_ID,
        assistant_id=ASSISTANT_ID
    )
    
    # Wait for the run to complete
    while True:
        run_status = client.beta.threads.runs.retrieve(
            thread_id=THREAD_ID,
            run_id=run.id
        )
        if run_status.status == "completed":
            break
        time.sleep(1)
    
    # Get the assistant's messages
    messages = client.beta.threads.messages.list(
        thread_id=THREAD_ID
    )
    
    # Return the latest assistant message
    for message in messages.data:
        if message.role == "assistant":
            return message.content[0].text.value
    
    return "No response received."

# Example interaction
if __name__ == "__main__":
    # Replace with your actual goal
    goal = """
    I want to create a content strategy for my tech blog focused on AI tools for small businesses.
    Help me develop a 3-month content plan with specific article ideas, posting schedule, and promotion strategy.
    """
    
    response = send_message(goal)
    print("\nAssistant Response:\n")
    print(response)

Update the ASSISTANT_ID and THREAD_ID variables with the values you saved earlier.

Run the script to interact with your assistant:

bash

python interact.py

Step 5: Make Your Assistant More Agentic (15 minutes)

To enhance the agentic capabilities of your assistant, let's add function calling to allow it to take specific actions. Create a file named agentic_assistant.py:

python

import os
import time
import json
from datetime import datetime, timedelta
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Replace with your actual IDs
ASSISTANT_ID = "your_assistant_id_here"
THREAD_ID = "your_thread_id_here"

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_topics",
            "description": "Search for trending topics related to a specific domain",
            "parameters": {
                "type": "object",
                "properties": {
                    "domain": {
                        "type": "string",
                        "description": "The domain or industry to search for trending topics"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "The maximum number of topics to return"
                    }
                },
                "required": ["domain"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "generate_content_calendar",
            "description": "Generate a content calendar for a specified time period",
            "parameters": {
                "type": "object",
                "properties": {
                    "start_date": {
                        "type": "string",
                        "description": "The start date for the calendar (YYYY-MM-DD)"
                    },
                    "end_date": {
                        "type": "string",
                        "description": "The end date for the calendar (YYYY-MM-DD)"
                    },
                    "frequency": {
                        "type": "string",
                        "description": "How often to post content (daily, weekly, bi-weekly, monthly)"
                    },
                    "topics": {
                        "type": "array",
                        "items": {
                            "type": "string"
                        },
                        "description": "List of topics to include in the calendar"
                    }
                },
                "required": ["start_date", "end_date", "frequency"]
            }
        }
    }
]

# Update the assistant with tools
client.beta.assistants.update(
    assistant_id=ASSISTANT_ID,
    tools=tools
)

# Function implementations
def search_topics(domain, limit=5):
    """Simulate searching for trending topics"""
    # In a real implementation, this would call an external API or database
    trending_topics = {
        "ai": [
            "Agentic AI applications in small business",
            "AI-powered customer service automation",
            "Low-code AI tools for non-technical users",
            "ROI measurement for AI implementations",
            "Privacy-preserving AI for sensitive data",
            "AI integration with legacy systems",
            "Vertical-specific AI solutions"
        ],
        "small business": [
            "Digital transformation for small retailers",
            "Automation tools for solopreneurs",
            "AI-powered marketing on a budget",
            "Customer data platforms for small businesses",
            "Subscription models for service businesses",
            "Remote team management tools",
            "Local SEO strategies for 2025"
        ]
    }
    
    # Get topics for the requested domain or return a default message
    topics = trending_topics.get(domain.lower(), ["No trending topics found for this domain"])
    return topics[:limit]

def generate_content_calendar(start_date, end_date, frequency, topics=None):
    """Generate a content calendar based on parameters"""
    # Parse dates
    start = datetime.strptime(start_date, "%Y-%m-%d")
    end = datetime.strptime(end_date, "%Y-%m-%d")
    
    # Determine posting interval
    if frequency == "daily":
        interval = timedelta(days=1)
    elif frequency == "weekly":
        interval = timedelta(weeks=1)
    elif frequency == "bi-weekly":
        interval = timedelta(weeks=2)
    else:  # monthly
        interval = timedelta(days=30)
    
    # Generate calendar
    calendar = []
    current_date = start
    topic_index = 0
    
    while current_date <= end:
        if topics and len(topics) > 0:
            topic = topics[topic_index % len(topics)]
            topic_index += 1
        else:
            topic = "TBD"
        
        calendar.append({
            "date": current_date.strftime("%Y-%m-%d"),
            "topic": topic,
            "status": "Planned"
        })
        
        current_date += interval
    
    return calendar

def process_tool_calls(tool_calls):
    """Process tool calls from the assistant"""
    results = []
    
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        
        if function_name == "search_topics":
            domain = function_args.get("domain")
            limit = function_args.get("limit", 5)
            result = search_topics(domain, limit)
        elif function_name == "generate_content_calendar":
            start_date = function_args.get("start_date")
            end_date = function_args.get("end_date")
            frequency = function_args.get("frequency")
            topics = function_args.get("topics", [])
            result = generate_content_calendar(start_date, end_date, frequency, topics)
        else:
            result = {"error": f"Unknown function: {function_name}"}
        
        # Submit the tool outputs
        client.beta.threads.runs.submit_tool_outputs(
            thread_id=THREAD_ID,
            run_id=tool_call.id,
            tool_outputs=[
                {
                    "tool_call_id": tool_call.id,
                    "output": json.dumps(result)
                }
            ]
        )
        
        results.append({
            "function": function_name,
            "result": result
        })
    
    return results

def interact_with_assistant(message_content):
    """Send a message to the assistant and handle the complete interaction"""
    # Add the user message to the thread
    client.beta.threads.messages.create(
        thread_id=THREAD_ID,
        role="user",
        content=message_content
    )
    
    # Run the assistant on the thread
    run = client.beta.threads.runs.create(
        thread_id=THREAD_ID,
        assistant_id=ASSISTANT_ID
    )
    
    # Wait for the run to complete or require action
    while True:
        run_status = client.beta.threads.runs.retrieve(
            thread_id=THREAD_ID,
            run_id=run.id
        )
        
        if run_status.status == "completed":
            break
        elif run_status.status == "requires_action":
            # Process required actions (tool calls)
            tool_calls = run_status.required_action.submit_tool_outputs.tool_calls
            process_tool_calls(tool_calls)
        elif run_status.status in ["failed", "cancelled", "expired"]:
            return f"Run ended with status: {run_status.status}"
        
        time.sleep(1)
    
    # Get the assistant's messages
    messages = client.beta.threads.messages.list(
        thread_id=THREAD_ID
    )
    
    # Return the latest assistant message
    for message in messages.data:
        if message.role == "assistant":
            return message.content[0].text.value
    
    return "No response received."

# Example interaction
if __name__ == "__main__":
    # Example goal that will trigger agentic behavior
    goal = """
    I need a content strategy for my AI tools blog. 
    First, find trending topics in the AI space.
    Then, create a content calendar for the next 2 months with weekly posts.
    Finally, suggest how I should promote this content.
    """
    
    print("Sending request to agentic assistant...\n")
    response = interact_with_assistant(goal)
    print("\nAssistant Response:\n")
    print(response)

Update the ASSISTANT_ID and THREAD_ID variables with your values and run:

bash

python agentic_assistant.py

Step 6: Observe Agentic Behavior in Action

Notice how the assistant:

1. Breaks down your goal into manageable steps

2. Proactively calls functions to gather information and create resources

3. Makes decisions about what information is relevant

4. Synthesizes a complete strategy based on the collected information

5. Maintains context throughout the interaction

This demonstrates the key differences between traditional and agentic AI:

• It's proactive rather than reactive

• It handles a multi-step workflow without explicit instructions for each step

• It makes decisions about what tools to use and when

• It adapts its response based on the information it gathers

Taking It Further:

To make your assistant even more agentic, consider:

1. Adding more tools: Expand functionality with tools for content analysis, SEO research, or social media posting.

2. Implementing feedback loops: Allow the assistant to learn from the success of its recommendations.

3. Creating agent specialization: Develop multiple assistants with different specialties that can collaborate.

4. Adding memory persistence: Store important information in a database for long-term reference.

5. Implementing scheduled runs: Have your assistant proactively check for new information or perform regular tasks.

The key to effective agentic AI is giving it clear goals while allowing flexibility in how it achieves them. As you experiment, focus on defining what success looks like rather than prescribing exact steps—this allows the agentic capabilities to shine.

WHAT'S NEXT

Next week, we'll explore "Building Multi-Agent Systems for Content Creation" – a deep dive into how multiple specialized AI agents can work together to transform your creative workflow.

Until then, experiment with the OpenAI Assistants API tutorial and let us know what you build!

john

Founder, Tech4SSD