All things AI agents and ML algorithms.

The Future of Agentic AI: Transforming the Web and the Future of Work

Andrei Oprisan
Andrei Oprisan

The Future of Agentic AI: Transforming the Web and the Future of Work

As we advance into the future, the concept of agentic AI is poised to revolutionize not only the web but also the very nature of work. Envision a world where networks of intelligent agents collaborate seamlessly, each possessing specialized skills and the ability to interact with other agents. This paradigm shift presents a unique opportunity to redefine how tasks are executed, moving away from traditional SaaS interfaces towards a future dominated by agent-to-agent communication and collaboration.

The Dawn of Agentic AI

Agentic AI refers to autonomous software entities that can perform tasks, make decisions, and interact with other agents and humans to achieve specific goals. Unlike traditional AI, which operates within the confines of a single application or service, agentic AI can traverse different environments, leveraging its skills to deliver outcomes efficiently and effectively.

In this envisioned future, agents will not only perform discrete tasks but also orchestrate complex workflows by dynamically calling upon other agents with complementary skills. This evolution marks a significant departure from current models, where SaaS applications serve as the primary interface for digital work.

Reshaping Work and SaaS: A Network of Agents

The shift towards agentic AI represents a fundamental transformation in how work will be accomplished. Here’s how it will unfold:

  1. Decentralized Workflows: Instead of relying on centralized SaaS platforms, work will be distributed across a network of specialized agents. Each agent will perform specific tasks and collaborate with other agents to complete complex processes.

  2. Enhanced Efficiency: Agents, equipped with advanced machine learning and natural language processing capabilities, will automate routine tasks, enabling humans to focus on higher-order thinking and creativity.

  3. Inter-Agent Communication: Agents will communicate using standardized protocols, facilitating seamless interoperability and data exchange. This agent-to-agent interaction will enable sophisticated task automation and coordination.

  4. Dynamic Skill Utilization: Agents will possess a range of skills, from data analysis and content creation to customer support and process management. They will dynamically acquire and apply these skills based on the requirements of the task at hand.

  5. Elimination of Traditional SaaS Interfaces: As agents take over the execution of tasks, the need for user-facing SaaS interfaces will diminish. The future will see a decline in traditional SaaS models, with agents becoming the primary actors in the digital ecosystem.

Proposing an Agent Markup Definition Language

To harness the full potential of agentic AI, a standardized language for defining agents and their interactions is essential. We propose an Agent Markup Definition Language (AMDL) based on YAML, which allows for clear, human-readable configuration of agents, their skills, and their interactions.

Agent Configuration Example
# Agent Configuration
agent:
  name: ExampleAgent
  version: 1.0
  description: This agent processes data and generates reports.
  settings:
    llms:
      - name: gpt-4o
        provider: OpenAI
        key: "your_gpt4o_api_key"
      - name: gemini-1.5-pro
        provider: GeminiAI
        key: "your_gemini_api_key"
      - name: perplexity
        provider: PerplexityAI
        key: "your_perplexity_api_key"
    extra_apis:
      - name: weather_api
        endpoint: "https://api.weather.com/v3/wx/forecast"
        key: "your_weather_api_key"
        openapi_spec: "https://api.weather.com/v3/openapi.json"
        input:
          parameters:
            - name: location
              type: string
              description: Location to get the weather forecast for.
              required: true
            - name: units
              type: string
              description: Units for temperature (metric or imperial).
              required: false
              enum: [metric, imperial]
        output:
          properties:
            temperature:
              type: number
              description: Current temperature.
            description:
              type: string
              description: Weather description.
      - name: news_api
        endpoint: "https://newsapi.org/v2/top-headlines"
        key: "your_news_api_key"
        openapi_spec: "https://newsapi.org/v2/openapi.json"
        input:
          parameters:
            - name: country
              type: string
              description: Country code for top headlines.
              required: true
            - name: category
              type: string
              description: News category (e.g., technology, sports).
              required: false
        output:
          properties:
            articles:
              type: array
              items:
                type: object
                properties:
                  title:
                    type: string
                    description: Title of the news article.
                  description:
                    type: string
                    description: Description of the news article.
  skills:
    - skill: fetch_weather_data
      description: Fetches weather data from the weather API.
      llm_processing:
        inputs:
          - name: location
            source: user_input
          - name: units
            source: user_input
        output:
          name: weather_data
          source: weather_api
    - skill: fetch_news_data
      description: Fetches news data from the news API.
      llm_processing:
        inputs:
          - name: country
            source: user_input
          - name: category
            source: user_input
        output:
          name: news_data
          source: news_api
    - skill: generate_weather_report
      description: Generates a report based on weather data.
      dependencies:
        - weather_data
      output:
        name: weather_report
        type: text
        content: |
          The weather in {{location}} is currently {{weather_data.temperature}} degrees with {{weather_data.description}}.
    - skill: generate_news_summary
      description: Generates a summary of top news headlines.
      dependencies:
        - news_data
      output:
        name: news_summary
        type: text
        content: |
          Here are the top news headlines for {{news_data.country}}:
          {% for article in news_data.articles %}
          - {{article.title}}: {{article.description}}
          {% endfor %}
    - skill: generate_news_table
      description: Generates a table of top news headlines.
      dependencies:
        - news_data
      output:
        name: news_table
        type: table
        headers: ["Title", "Description"]
        rows: |
          {% for article in news_data.articles %}
          - ["{{article.title}}", "{{article.description}}"]
          {% endfor %}

# Output Types
output:
  - type: text
    content: |
      {{weather_report.content}}

  - type: text
    content: |
      {{news_summary.content}}

  - type: table
    headers: ["Title", "Description"]
    rows:
      {{news_table.rows}}

Fields Specification

  • Agent: Defines the agent's identity and core attributes.

    • name: The name of the agent.
    • version: The version of the agent.
    • description: A brief description of the agent's purpose.
    • settings: Configuration settings for LLMs and APIs.
      • llms: List of large language models used by the agent.
      • extra_apis: List of additional APIs used by the agent, including their input and output definitions based on the OpenAPI specification.

  • Skills: Represents the abilities of the agent.

    • skill: Name of the skill.
    • description: Description of what the skill does.
    • llm_processing: Defines how the skill uses LLM inputs and generates outputs.
      • inputs: Input parameters for the skill.
      • output: The output object created by the skill.
    • dependencies: Other skills' outputs required by this skill.
    • output: The output produced by the skill, formatted for use in the overall output.

  • Output: Defines the output structure of the agent.

    • type: Type of output (e.g., text, table).
    • content: Content for text output, utilizing dynamic data from skills.
    • headers: Column headers for table output.
    • rows: Rows for table output, populated with data from skills.

Embracing the Future

The future of the web and work lies in the seamless integration of intelligent agents, each contributing its specialized skills to create a cohesive and efficient workflow. By adopting an agentic AI framework and a standardized markup language like AMDL, we can unlock unprecedented levels of productivity and innovation, transforming the digital landscape and how we approach work itself. The age of agent-to-agent communication is upon us, heralding a new era where work is no longer constrained by interfaces but defined by intelligent, autonomous collaboration.