Hi Community,

In this article, I will introduce my application iris-AgenticAI .

The rise of agentic AI marks a transformative leap in how artificial intelligence interacts with the world—moving beyond static responses to dynamic, goal-driven problem-solving. Powered by OpenAI’s Agentic SDK , The OpenAI Agents SDK enables you to build agentic AI apps in a lightweight, easy-to-use package with very few abstractions. It's a production-ready upgrade of our previous experimentation for agents, Swarm.
This application showcases the next generation of autonomous AI systems capable of reasoning, collaborating, and executing complex tasks with human-like adaptability.

Application Features

• Agent Loop 🔄 A built-in loop that autonomously manages tool execution, sends results back to the LLM, and iterates until task completion.
• Python-First 🐍 Leverage native Python syntax (decorators, generators, etc.) to orchestrate and chain agents without external DSLs.
• Handoffs 🤝 Seamlessly coordinate multi-agent workflows by delegating tasks between specialized agents.
• Function Tools ⚒️ Decorate any Python function with @tool to instantly integrate it into the agent’s toolkit.
• Tracing 🔍 Built-in tracing to visualize, debug, and monitor agent workflows in real time (think LangSmith alternatives).
• MCP Servers 🌐 Support for Model Context Protocol (MCP) via stdio and HTTP, enabling cross-process agent communication.
• Chainlit UI 🖥️ Integrated Chainlit framework for building interactive chat interfaces with minimal code.
• Stateful Memory 🧠 Preserve chat history, context, and agent state across sessions for continuity and long-running tasks.

Agent

Agents are the core building block in your apps. An agent is a large language model (LLM), configured with instructions and tools. Basic configuration The most common properties of an agent you'll configure are:

Instructions: also known as a developer message or system prompt.
model: which LLM to use, and optional model_settings to configure model tuning parameters like temperature, top_p, etc.
tools: Tools that the agent can use to achieve its tasks.

from agents import Agent, ModelSettings, function_tool

@function_tool
def get_weather(city: str) -> str:
    return f"The weather in {city} is sunny"
agent = Agent(
    name="Haiku agent",
    instructions="Always respond in haiku form",
    model="o3-mini",
    tools=[get_weather],
)

Running agents

You can run agents via the Runner class. You have 3 options:

1. Runner.run(), which runs async and returns a RunResult.
2. Runner.run_sync(), which is a sync method and just runs .run() under the hood.
3. Runner.run_streamed(), which runs async and returns a RunResultStreaming. It calls the LLM in streaming mode, and streams those events to you as they are received.

from agents import Agent, Runner

async def main():
    agent = Agent(name="Assistant", instructions="You are a helpful assistant")

    result = await Runner.run(agent, "Write a haiku about recursion in programming.")
    print(result.final_output)
    # Code within the code,
    # Functions calling themselves,
    # Infinite loop's dance.

Agent Architecture

The application comprises 7 specialized agents:

1. Triage Agent 🤖
   • Role: Primary router that receives user input and delegates tasks via handoffs
   • Example: Routes "Show production errors" → IRIS Production Agent  
2. IRIS Dashboard Agent 🤖
   • Function: Provides real-time management portal metrics: plaintext Copy

     ApplicationErrors, CSPSessions, CacheEfficiency, DatabaseSpace, DiskReads,  
     DiskWrites, ECPAppServer, ECPDataServer, GloRefs, JournalStatus,  
     LicenseCurrent, LockTable, Processes, SystemUpTime, WriteDaemon, [...]

3. IRIS Running Process Agent 🤖
   • Function: Monitors active processes with details:
     • Process ID | Namespace | Routine | State | PidExternal
4. IRIS Production Agent 🤖
   • Role: Provide production details along with the functionality to start and stop the production.
5. WebSearch Agent 🤖
   • Capability: Performs contextual web searches via API integrations
6. Order Agent 🤖
   • Function: Retrieves order status using an order ID

Handoffs

Handoffs allow an agent to delegate tasks to another agent. This is particularly useful in scenarios where different agents specialize in distinct areas. For example, a customer support app might have agents that each specifically handle tasks like order status, refunds, FAQs, etc.

The triage agent is our main agent, which delegates tasks to another agent based on user input

triage_agent = Agent(
        name="Triage agent",
        instructions=(
            "Handoff to appropriate agent based on user query."
            "If they ask about production, handoff to the production agent."
            "If they ask about dashboard, handoff to the dashboard agent."
            "If they ask about process, handoff to the processes agent."
            "Use the WebSearchAgent tool to find information related to the user's query."
            "If they ask about order, handoff to the order_agent."
        ),
        handoffs=[production_agent,dashboard_agent,processes_agent,web_search_agent,order_agent]
    )

Tracing

The Agents SDK includes built-in tracing, collecting a comprehensive record of events during an agent run: LLM generations, tool calls, handoffs, guardrails, and even custom events that occur. Using the Traces dashboard, you can debug, visualize, and monitor your workflows during development and in production.
https://platform.openai.com/logs

 

Application Interface

Application Workflow Process

The Triage Agent receives user input, routing the question to the IRIS Dashboard Agent.


The Triage Agent receives user input, routing the question to the IRIS Processes Agent.


Start and Stop the Production by using Production Agent.


Get Production Details by using Production Agent.

The Triage Agent receives user input, routing the question to the Local Order Agent.


Here, the triage Agent receives two questions, routing both to the WebSearcg Agent.

MCP Server application

MCP Server is running at https://localhost:8000/sse

Below is the code to start the MCP server:

import os
import shutil
import subprocess
import time
from typing import Any
from dotenv import load_dotenv

load_dotenv()

#Get OPENAI Key, if not fond in .env then get the GEIMINI API KEY
#IF Both defined then take OPENAI Key 
openai_api_key = os.getenv("OPENAI_API_KEY")
if not openai_api_key:
   raise ValueError("OPENAI_API_KEY is not set. Please ensure to defined in .env file.")


if __name__ == "__main__":
    # Let's make sure the user has uv installed
    if not shutil.which("uv"):
        raise RuntimeError(
            "uv is not installed. Please install it: https://docs.astral.sh/uv/getting-started/installation/"
        )

    # We'll run the SSE server in a subprocess. Usually this would be a remote server, but for this
    # demo, we'll run it locally at http://localhost:8000/sse
    process: subprocess.Popen[Any] | None = None
    try:
        this_dir = os.path.dirname(os.path.abspath(__file__))
        server_file = os.path.join(this_dir, "MCPserver.py")

        print("Starting SSE server at http://localhost:8000/sse ...")

        # Run `uv run server.py` to start the SSE server
        process = subprocess.Popen(["uv", "run", server_file])
        # Give it 3 seconds to start
        time.sleep(3)

        print("SSE server started. Running example...\n\n")
    except Exception as e:
        print(f"Error starting SSE server: {e}")
        exit(1)

 

The MCP Server is equipped with the following tools:

• IRIS Info tool
• Check Weather tool
• Find secret word tool (Local function)
• Addition Tool (Local function)

import random,iris
import requests
from mcp.server.fastmcp import FastMCP

# Create server
mcp = FastMCP("Echo Server")

#Local function
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    print(f"[debug-server] add({a}, {b})")
    return a + b

#Local Function
@mcp.tool()
def get_secret_word() -> str:
    print("[debug-server] get_secret_word()")
    return random.choice(["apple", "banana", "cherry"])

#Get IRIS Version details
@mcp.tool()
def get_iris_version() -> str:
    print("[debug-server] get_iris_version()")
    return iris.system.Version.GetVersion()

#Get Current weather
@mcp.tool()
def get_current_weather(city: str) -> str:
    print(f"[debug-server] get_current_weather({city})")

    endpoint = "https://wttr.in"
    response = requests.get(f"{endpoint}/{city}")
    return response.text

if __name__ == "__main__":
    mcp.run(transport="sse")

 

MCP application is running at  http://localhost:8001


The MCP Server dynamically delegates tasks to the appropriate tool based on user input.

For more details, please visit iris-AgenticAI open exchange application page.

Thanks