← All insights

Insights

Building Autonomous Agents: Advanced Tools and Architectures

In the realm of artificial intelligence, few concepts capture the imagination like the notion of an autonomous agent — a software system that can perceive, reason, act, and learn on its own. Thanks to advances in natural language processing, knowledge representation, and machine learning, that idea is moving from science fiction into production.

The path from scripted chatbots to autonomous problem-solvers is not a simple one. It requires a fundamentally different approach to architecture and a suite of advanced tools. At Oxydata, we have been on the forefront of this transition, building real-world agentic AI systems like IRIS and Oxa for Malaysian enterprises. This post shares key lessons from that work — and a practical guide to the tools and architectures needed to build autonomous agents.

The Agentic AI Technology Stack 2.0

Vectorized Knowledge Bases

The foundation of any agentic AI system is its knowledge base — the corpus of information it draws upon to understand the world and make decisions. In early iterations of Oxa, we used Airtable as our primary knowledge store. Airtable's flexible schema and easy integration made it a great choice for rapid prototyping. As Oxa's knowledge requirements grew in size and complexity, we started to run into scalability issues.

The solution was to migrate to PostgreSQL with the pgvector extension. Pgvector allows semantic search and retrieval on high-dimensional vector embeddings of text data. By representing each chunk of knowledge as a dense vector, we can efficiently find relevant information even in a vast knowledge base.

Here is a simplified example of how we create an embedding and insert it into our Postgres knowledge base:

import pgvector
from sentence_transformers import SentenceTransformer

# Load a pre-trained embedding model
embedder = SentenceTransformer('all-MiniLM-L6-v2')

# Connect to the database
conn = pgvector.connect(
    host='localhost',
    port=5432,
    dbname='oxa_kb'
)

# Create a table to store the embeddings
cur = conn.cursor()
cur.execute('''
    CREATE TABLE IF NOT EXISTS knowledge (
        id SERIAL PRIMARY KEY,
        text TEXT,
        embedding VECTOR(384)
    )
''')

# Insert a new chunk of knowledge
text = "Oxydata is a leading provider of agentic AI solutions."
embedding = embedder.encode(text)

cur.execute('''
    INSERT INTO knowledge (text, embedding)
    VALUES (%s, %s)
''', (text, embedding))

conn.commit()

With this setup, we can perform efficient semantic searches over our entire knowledge base, even as it scales to millions of entries:

query = "What does Oxydata specialize in?"
query_embedding = embedder.encode(query)

cur.execute('''
    SELECT text
    FROM knowledge
    ORDER BY embedding <=> %s
    LIMIT 1
''', (query_embedding,))

result = cur.fetchone()[0]
print(result)  # Outputs: "Oxydata is a leading provider of agentic AI solutions."

This vectorized knowledge base forms the foundation of Oxa's ability to understand and reason about its domain. But to truly achieve agentic AI, we need more than just a knowledge base.

Language-Aware Graphs and Reasoning

While a vectorized knowledge base provides a strong foundation, truly agentic AI requires the ability to perform complex reasoning and draw insights from interconnected concepts. This is where language-aware graphs and reasoning engines like LangGraph come into play.

LangGraph is an open-source framework for building and querying language-aware knowledge graphs. It allows us to represent domain knowledge as a graph of entities and relationships, each associated with rich natural language descriptions. In Oxa's knowledge graph, we might have entities like Oxydata, Agentic AI, and IRIS, connected by relationships like develops and is_an_example_of.

from langgraph.graph import StateGraph

# Simplified entity-relationship model
entities = {
    "Oxydata": "A leading provider of agentic AI solutions",
    "Agentic AI": "AI systems that can autonomously perceive, reason, act and learn",
    "IRIS": "An agentic AI system for WhatsApp recruitment developed by Oxydata",
}

relationships = [
    ("Oxydata", "develops", "IRIS"),
    ("IRIS", "is_an_example_of", "Agentic AI"),
]

With knowledge represented as a language-aware graph, we can perform complex queries and reasoning using orchestration layers that combine language models, knowledge graphs, and reasoning algorithms to enable open-ended question answering and task completion.

Suppose a user asks Oxa: "What agentic AI systems has Oxydata developed for recruitment?" The system can break this down into steps:

  1. Use a language model to understand the intent and identify key entities (Oxydata, agentic AI systems, recruitment).
  2. Query the knowledge graph to find matching entities (e.g., IRIS).
  3. Use the language model to generate a natural language response based on the graph query results.

By combining language-aware graphs with powerful reasoning engines, we create AI systems that can engage in complex, open-ended dialogue and problem-solving — a significant step towards truly agentic AI.

Composable Tool Chains

In the early days of AI development, most systems were monolithic and hard-coded for specific tasks. As AI capabilities have grown, there has been a shift towards modular, composable architectures — building AI systems not as single rigid programs, but as flexible chains of interoperable tools and services.

At Oxydata, we have embraced this philosophy. Oxa is not a single model or script, but a dynamic composition of multiple AI tools and services, each handling a specific aspect of the overall task:

  • A language model for natural language understanding and generation
  • A vectorized knowledge base (Postgres with pgvector) for efficient information retrieval
  • A language-aware graph for complex reasoning and question answering
  • Domain-specific microservices for tasks like candidate scoring, interview scheduling, and reporting
  • General-purpose AI tools for web search, document analysis, and data visualization

Each component is defined by a standard interface, allowing them to be seamlessly combined and orchestrated:

class CandidateScoringTool:
    def __init__(self, model_path):
        self.model = load_model(model_path)

    def score_candidate(self, candidate_profile):
        scores = self.model.predict(candidate_profile)
        return scores

# Register the tool with Oxa's tool chain
oxa.register_tool(
    name="candidate_scorer",
    description="Scores a candidate based on their profile",
    parameters=[
        {"name": "candidate_profile", "type": "dict"}
    ],
    return_type="dict",
    run=CandidateScoringTool("path/to/model").score_candidate
)

When a new candidate applies, Oxa might retrieve their profile, score their fit, propose interview times if the score is above threshold, generate a personalized response, and send it — each step invoking a different tool in the chain.

This modular approach provides flexibility (new tools can be added or swapped), interpretability (each step is explicit and debuggable), and scalability (tools can be distributed and scaled independently). Frameworks like LangChain provide high-level abstractions for defining and executing these kinds of AI workflows.

A Reference Architecture for Enterprise Agentic AI

Now that we have explored the key components — vectorized knowledge bases, language-aware graphs, and composable tool chains — let us see how they fit together. Here is a reference architecture for enterprise agentic AI, drawn from our experience building IRIS and OPAL.

At a high level, the architecture consists of four main layers:

  1. Data Layer — vectorized knowledge base (Postgres with pgvector) and other databases or data stores
  2. Tool Layer — individual AI tools and microservices (language models, reasoning engines, domain services, general-purpose AI tools)
  3. Orchestration Layer — tool registry and orchestration frameworks (LangChain, custom reasoning pipelines)
  4. Interaction Layer — conversational UI, task-specific UI, and API endpoints
flowchart TB
    User[End User]

    subgraph IL["Interaction Layer"]
        CUI[Conversational UI]
        TUI[Task-Specific UI]
        API[API]
    end

    subgraph OL["Orchestration Layer"]
        TR[Tool Registry]
        LC[LangChain]
        RE[Reasoning Engine]
    end

    subgraph TL["Tool Layer"]
        LM[Language Models]
        RN[Reasoning Engines]
        DS[Domain-Specific Services]
        GP[General-Purpose AI Tools]
    end

    subgraph DL["Data Layer"]
        VKB[Vectorized KB]
        ODB[Other Databases]
    end

    User --> IL
    IL --> OL
    OL --> TL
    TL --> DL

How the architecture works in practice

Suppose a user interacts with Oxa via its conversational UI, asking: "What are the top skills for data science candidates?"

  1. The Interaction Layer receives the query and passes it to the Orchestration Layer.
  2. The Orchestration Layer breaks the query into steps: understand intent, query the knowledge base, rank skills by importance, generate a natural language response.
  3. For each step, the Orchestration Layer consults the Tool Registry to find the appropriate tool and invokes it.
  4. Invoked tools interact with the Data Layer as needed.
  5. Results are composed into a final response and returned to the user.
# In the Interaction Layer
query = "What are the top skills for data science candidates?"
response = oxa.answer(query)

# In the Orchestration Layer
def answer(query):
    intent = language_model.understand(query)

    if intent == "data_science_skills":
        skills = knowledge_base.query("data science skills")
        ranked_skills = reasoning_engine.rank(skills)
        return language_model.generate(ranked_skills)

# In the Tool Layer — each tool has a clear, single responsibility

The core principles: modularity (each layer has a clear responsibility), flexibility (components can be swapped or upgraded), and extensibility (new capabilities added via new tools in the orchestration flow).

Implementing Agentic AI: Team, Talent, and Trajectory

Building agentic AI systems requires a unique combination of skills. At Oxydata, our agentic AI teams bring together:

  • AI Engineers — machine learning, NLP, knowledge representation, and reasoning
  • Software Engineers — scalable, resilient systems and diverse technology integration
  • Domain Experts — deep knowledge of the specific industry and use case
  • Product Managers — alignment with business goals and user needs
  • Designers — intuitive experiences that harness AI power

Beyond individual skills, building agentic AI requires a particular approach to team organization:

  • Cross-functional collaboration from ideation through implementation
  • Agile experimentation — rapid prototyping, frequent iteration, continuous learning
  • Phased rollout — start with a narrow MVP, then expand based on feedback

For many enterprises, building this capability in-house is challenging given AI talent scarcity and a rapidly evolving landscape. Partnerships with experienced agentic AI providers can accelerate the journey. Typical engagement models include:

  • Pilot projects — rapidly prototype an agentic AI solution for a specific use case
  • Co-development — build and deploy a production-grade system while building in-house capability
  • Platform licensing — leverage pre-built agentic AI foundations, customized for enterprise needs

Conclusion

The advent of agentic AI represents a major shift in how we conceive of and interact with artificial intelligence. Rather than narrow, scripted systems, we are moving towards AI that can autonomously perceive, reason, act, and learn — engaging in open-ended dialogue, tackling complex problems, and continuously improving.

At Oxydata, we are at the forefront of this transition, pioneering agentic AI solutions for Malaysian enterprises through IRIS, Oxa, and OPAL. The tools and architectures described here are the same foundations we use in production — not theoretical patterns, but battle-tested design choices.

If you are exploring how agentic AI could transform your business — whether piloting a specific use case, building in-house capability, or leveraging our platform — talk to our team or explore our GenAI & Agentic Services.

Oxydata Software Sdn Bhd is a Malaysia Digital-certified Microsoft Technology Partner based in Petaling Jaya.