Available for AI/ML Engineering Roles

Adam Simonar

AI Engineer

Specializing in multi-agent systems, RAG architectures, and LLM applications. Building production-ready AI agents with LangChain, LangGraph, and modern AI frameworks.

Featured Projects

Production-ready AI systems demonstrating multi-agent architectures, RAG patterns, and LLM applications

RAG Self-Correction

Self-Correcting RAG Agent

Advanced retrieval-augmented generation with hallucination detection and self-correction. Automatic verification against source documents with web search fallback.

LangGraph Claude 3.5 Qdrant Streamlit
Multi-Agent Research

Deep Research Agent

Parallel research execution with supervisor-researcher architecture. Multi-model support via OpenRouter with automatic citation tracking and full LangSmith observability.

LangGraph OpenRouter Tavily LangSmith
Multi-Agent MCP

AI Teaching Agent Team

Multi-agent education system with Professor, Academic Advisor, Research Librarian, and Teaching Assistant agents. Creates comprehensive learning packages with Google Docs integration.

LangGraph LangChain MCP/Composio Google Docs API
Fine-Tuning QLoRA

RegexGPT

Fine-tuned LLM converting natural language to regex patterns. QLoRA fine-tuning of Mistral 7B on ~7,000 NL-to-regex pairs with functional evaluation and live testing.

Transformers PEFT TRL QLoRA Gradio

Technical Skills

AI/ML Engineering

  • LangChain, LangGraph, LangSmith
  • RAG Systems (Self-RAG, Corrective RAG)
  • Multi-Agent Architectures
  • LLM Fine-tuning (QLoRA, PEFT)
  • Vector Databases (Qdrant, ChromaDB)
  • Robotics Simulation (PyBullet)

LLM Providers

  • Anthropic Claude
  • OpenAI GPT-4
  • Google Gemini
  • xAI Grok
  • OpenRouter, Ollama

Development

  • Python, TypeScript
  • React, Next.js
  • Streamlit, Gradio
  • FastAPI, Flask
  • Git/GitHub

Security

  • OSCP Certified
  • CompTIA Security+
  • CompTIA Network+
  • Blockchain Security

Blog

Thoughts on AI engineering, agent architectures, and lessons learned building production systems

January 20, 2026 Voice AI

Building an AI Voice Agent That Calls Leads in 20 Seconds

Lead response time impact on conversion rates

There's a brutal reality in sales: wait 5 minutes to call a lead and your odds of qualifying them drop by 80%. I built an AI voice agent that makes the first call within seconds of form submission, conducts a full qualification interview, and scores the lead automatically.

The Speed-to-Lead Problem

I've watched this happen too many times. Someone fills out a contact form, genuinely interested. An hour later, they've moved on. A day later, they can't remember why they reached out. The data backs this up:

  • Within 5 minutes: 100x more likely to qualify the lead
  • After 5 minutes: 80% drop in qualification odds
  • Within 20 seconds: 220% increase in conversions

Humans can't respond in 20 seconds. Not consistently. Not at scale. So I built something that can.

What AI Lead Qualifier Does

The system is straightforward: when someone submits a lead form, an AI voice agent calls them immediately. Not a robocall script—an actual conversational AI that conducts a BANT qualification interview.

BANT stands for Budget, Authority, Need, and Timeline. It's the standard framework for determining if a lead is worth pursuing:

  • Budget: "What budget range have you allocated for this?"
  • Authority: "Who else would be involved in evaluating solutions?"
  • Need: "What's driving your interest right now?"
  • Timeline: "When are you looking to have something in place?"

The AI asks these questions naturally, responds to the lead's answers, and extracts the qualification signals. After the call ends, it analyzes the transcript and scores the lead as hot, warm, or cold.

AI Lead Qualifier system architecture

The Architecture

I built this as a TypeScript monorepo with three main components:

  • Backend (Hono): Handles form submissions, Vapi webhooks, and transcript analysis. Runs on Bun for speed.
  • Frontend (React + Vite): Lead form with country code selector, real-time dashboard showing hot/warm/cold distribution, detailed lead view with full transcripts.
  • Database (PostgreSQL + Drizzle): Stores leads, call metadata, transcripts, and qualification scores with proper indexing.

The voice AI runs on Vapi.ai—they handle the telephony, speech-to-text, and text-to-speech. I send them a transient assistant configuration with the BANT system prompt, and they handle the call. When it ends, they hit my webhook with the full transcript.

The Intelligence Layer

Here's where it gets interesting. A transcript is just text. The intelligence comes from Claude (Anthropic's API) analyzing that transcript to extract structured qualification data.

The AI doesn't just look for keywords. It understands context:

  • A call that ends in 30 seconds? Probably a hangup. Score: cold.
  • Silence timeout? They stopped engaging. Score: cold.
  • Voicemail detected? No conversation happened. Score: cold.
  • Full conversation with timeline urgency? Score: hot.

This call-context awareness was critical. Without it, a polite voicemail greeting would score the same as a genuine interest conversation.

Key Technical Decisions

Transient Assistants: Instead of pre-creating Vapi assistants, I send the full configuration (system prompt, voice settings, model) with each call. This means the prompt can be customized per-lead or per-campaign without managing assistant state.

BYOK Architecture: The system supports Bring Your Own Keys. API keys can come from environment variables (production) or a Settings UI (development). No secrets in code, no vendor lock-in.

Auto-Migration: Database migrations run automatically on backend startup. No manual setup steps, no "forgot to run migrations" bugs.

E.164 Phone Format: International phone numbers need proper formatting. The frontend includes a country code selector that ensures numbers are always in E.164 format (+1XXXXXXXXXX) before hitting the API.

Cost Per Call

The economics work out to roughly $0.35 per call:

  • Vapi platform: ~$0.05
  • Deepgram (speech-to-text): ~$0.01
  • GPT-4 (conversation): ~$0.02-0.20 depending on length
  • ElevenLabs (voice): ~$0.036

Compare that to a human SDR's time. Even at minimum wage, a 5-minute call costs more—and you can't make 100 of them simultaneously.

What I'd Do Differently

A few things I'd reconsider in v2:

  • Claude for the voice agent itself: Currently using GPT-4 via Vapi for the actual conversation, Claude for transcript analysis. Vapi now supports Claude—worth testing for consistency.
  • Voicemail detection + callback scheduling: Right now voicemails just score as cold. A smarter system would detect voicemail, schedule a retry, and track attempts.
  • CRM integration: Leads live in PostgreSQL. In production, you'd want these flowing into Salesforce, HubSpot, or Pipedrive with automatic field mapping.

Try It Yourself

The project is open source. You'll need accounts with Vapi.ai and Anthropic, but beyond that it's plug and play:

git clone https://github.com/Sim-Security/AI-Lead-Qualifier
cd ai-lead-qualifier
cp .env.example .env
# Add your API keys
docker compose up -d

Dashboard runs on localhost. Submit a lead with your phone number, and you'll get a call within seconds.

View on GitHub →

The Takeaway

Speed matters in sales. The data is clear: respond in seconds, not minutes. AI voice agents make that possible at scale, with consistent qualification frameworks and automatic scoring.

This isn't about replacing salespeople. It's about making sure qualified leads actually reach them—warm, scored, and ready to close.

Read Full Post
January 14, 2026 AI Protocols

MCP vs A2A: The Difference Between Having Tools and Hiring Specialists

MCP vs A2A protocol comparison infographic

Two protocols are shaping how AI agents interact with the world: MCP gives agents tools to do work themselves, while A2A lets agents delegate to other agents entirely. Understanding the difference clicked for me when I thought about it like visiting a hardware store.

The Hardware Store Analogy

I've been building with both MCP (Model Context Protocol) and A2A (Agent2Agent Protocol), and for a while I couldn't articulate why they felt so different. Then I thought about hardware stores.

MCP is like walking into Home Depot and finding the nail gun yourself. You have skills: you can walk, read aisle signs, ask the kiosk, and pay at checkout. These are your "tools." You navigate the store, locate what you need, and handle the transaction. You need to understand the store's layout, and if you want something from Lowe's next, you learn a whole new layout.

A2A is like asking an employee to get you a nail gun. You describe what you need ("I'm doing framing work, need something reliable"). The employee knows the inventory, the layout, maybe even that one model has recalls. They handle everything internally - you just get the result. And here's the key: you can ask any store's employee the same way. The protocol for "asking a human for help" is universal.

Hardware store analogy for MCP vs A2A

This isn't just a cute analogy. It maps directly to how these protocols work.

What MCP Actually Does

First, let's be clear: "giving an agent tools" is just basic agentic behavior. Any framework can let an agent call functions. MCP is something more specific.

MCP (Model Context Protocol), developed by Anthropic, is a standardized protocol for connecting agents to external services. Think of it like USB for AI - a universal plug that works with any compatible service.

Without MCP, connecting an agent to Postgres requires custom code. Connecting to Slack requires different custom code. Every integration is bespoke. With MCP:

  • Discovery - Agent asks "what can you do?" and gets a capability list
  • Schema - Tools have typed inputs/outputs, automatically understood
  • Resources - Access to data, not just functions
  • Standard transport - JSON-RPC, works the same everywhere

If someone builds an MCP server for GitHub, any MCP-compatible agent can use it. No custom integration. The value isn't "tools" - it's the standardization of how tools get exposed and connected.

What A2A Actually Does

A2A, introduced by Google and now under the Linux Foundation, is a standard for agents to talk to other agents. Not tools - agents. Entities with their own reasoning, their own tools, their own way of solving problems.

When you call an A2A agent, you describe what you want. You don't tell it how. The weather agent might use an API, scrape a website, or ask another agent. You don't know and you don't care. You get the result.

The Critical Difference

With MCP, you're connecting to services. You get standardized access to tools and data, but you still orchestrate. You decide what to call, when, and how to use the results.

With A2A, you're delegating to another agent. You describe the outcome you want to an autonomous entity. That entity figures out how to deliver it - possibly using its own MCP connections, possibly calling other A2A agents, possibly doing something you never anticipated.

MCP standardizes the plug. A2A standardizes the conversation.

Why Both Exist (And Why You Need Both)

These aren't competitors. They're complementary.

MCP handles vertical integration - connecting an agent to data sources, APIs, and functions it needs to do its job.

A2A handles horizontal integration - connecting agents to each other across organizational boundaries.

Real example: I built a research agent that answers questions by searching the web and synthesizing results. Internally, it uses tools (MCP-style) to search DuckDuckGo and call an LLM. Externally, it exposes an A2A endpoint so any other agent can ask it questions without knowing how it works inside.

The agent uses tools. The agent is an A2A endpoint.

The Enterprise Play

Here's where A2A gets interesting at scale. Imagine:

  • Salesforce exposes a "customer lookup" agent
  • SAP exposes an "inventory check" agent
  • Stripe exposes a "payment processing" agent

Your internal agent needs to handle a customer order. Instead of integrating with three different APIs (each with their own auth, SDKs, rate limits), it just asks three A2A agents. Same protocol. Same message format. The specialists handle their domains.

This is why Google pushed A2A and the Linux Foundation adopted it. It's not about building better agents - it's about making agents interoperable across the entire ecosystem.

What I Learned Building an A2A Agent

I built a demo to test this. My AdamOS Research Agent exposes an A2A endpoint, and I had it work alongside public agents from the A2A registry (yes, there's already a registry with 100+ agents).

The aha moment: my agent and a "Hello World" agent on Render.com and a business AI on Lifie.ai all spoke the same protocol. I discovered their capabilities via their Agent Cards, called them with identical message formats, and got responses back. Different platforms, different implementations, same interface.

That's the promise. HTTP standardized how servers talk to each other. A2A standardizes how agents talk to each other.

The Takeaway

When you're building AI systems, think about:

Use MCP when you need your agent to do work directly - read files, query databases, call APIs. The agent is the worker, tools are its extensions.

Use A2A when you want to leverage capabilities you don't control - other organizations' agents, specialized services, domain experts. The agent is a delegator, other agents are specialists.

Or, back to the hardware store:

  • MCP = Learn to navigate the store yourself
  • A2A = Ask an employee and let them handle it

Both have their place. The future probably involves agents that use MCP internally while exposing A2A externally - specialists that can be hired by anyone.

We're still early. But the protocols are here, they're open, and they're already being used. Time to build.

Read Full Post
January 13, 2026 AI Architecture

Why Agents with Tools Beat RAG for Code Understanding

RAG vs Tool-Augmented Agents comparison infographic

After building both RAG systems and tool-augmented agents, I've learned that giving an agent exploration tools is far superior to traditional retrieval. Here's why chunking and embedding fundamentally breaks down for codebases - and probably for most complex domains.

The Problem with RAG for Code

Traditional RAG works like this: chunk your documents, embed them, store in a vector database, then retrieve "relevant" chunks based on semantic similarity. For simple Q&A over documents, this works reasonably well.

But codebases aren't documents. Code has structure. Functions call other functions. Classes inherit from other classes. A variable defined on line 10 might be used on line 500. When you chunk code arbitrarily, you destroy these relationships.

What Actually Happens with Code RAG

Say you ask: "How does the authentication flow work?" A RAG system might retrieve:

  • A chunk with half of the login function (the other half is in a different chunk)
  • Some random middleware that mentions "auth" in a comment
  • A test file that imports the auth module

The LLM then has to hallucinate the connections between these fragments. It has no way to trace the actual execution path, see the full function signatures, or understand how components interact.

The Tool-Augmented Approach

Instead of pre-computing what might be relevant, give the agent tools to explore:

  • list_directory_structure - See the project layout
  • read_file - Load complete source files
  • search_code - Grep for patterns across the codebase
  • get_imports - Trace dependency relationships
  • find_entry_points - Locate main functions

Now the agent can actually follow the code. It reads the login route, sees it calls authenticate(), searches for that function, reads the auth service, discovers it uses a token validator, and so on. It builds a complete mental model by exploring, not by hoping the right chunks appear.

The Context Window Advantage

Modern LLMs have 200k+ token context windows. That's roughly 500-1000 source files worth of code. You don't need embeddings and retrieval when you can just... read the files.

The "but what about large codebases?" objection misses the point. Even in a million-line codebase, understanding any particular feature rarely requires reading more than 20-30 files. The agent with tools can identify and load exactly those files.

Results from the Codebase Onboarding Agent

I built a tool-augmented agent to test this thesis. The results:

  • 96.7% accuracy across 10 diverse repositories in 5 languages
  • 0% hallucination rate - every claim cites specific file:line references
  • 100% tool usage - the agent explores rather than guesses

No embedding infrastructure. No vector database. No chunking strategy debates. Just tools and a capable model.

Beyond Code: A General Principle

This insight extends beyond codebases. Any domain with structure and relationships will suffer from RAG's chunking problem:

  • Legal documents that reference other sections
  • Technical specifications with dependencies
  • Research papers with citations and methodology chains
  • Database schemas with foreign key relationships

Whenever understanding requires following connections, tools beat retrieval.

The Takeaway

RAG was a clever solution when context windows were tiny and we needed ways to "cheat" information into the prompt. But we're in a different era now. Large context windows + tool use + capable reasoning = agents that can actually explore and understand, rather than pattern-match against pre-computed embeddings.

Give your agents tools to explore. Let them discover. The results speak for themselves.

Read Full Post

About Me

I'm an AI Engineer with a non-linear path through tech. Dual degrees in Mechanical Engineering and Computer Science taught me to decompose complex problems systematically. Earned my OSCP, explored blockchain security, and now I'm building production AI systems.

My portfolio includes 7 AI projects—multi-agent orchestration, RAG systems with hallucination detection, and LLM fine-tuning. The Codebase Onboarding Agent achieved 96.7% task success rate with zero hallucinations through systematic evaluation.

I build from first principles. AI is reshaping everything, and I want to be one of the people who helps shape how it impacts the world. Currently seeking AI/ML engineering roles in Saskatoon or remote.

Education

B.Sc. Computer Science University of Saskatchewan, 2019
B.Eng. Mechanical Engineering University of Saskatchewan, 2015

Certifications

OSCP Security+ Network+ AI/ML Certificate

Get In Touch

Open to AI/ML engineering opportunities. Based in Calgary, AB (open to Saskatoon, remote, or hybrid).