Not a slow pipeline. Zero pipeline.

I’d been doing what most founders do — building a list, writing emails, sending them, hoping. Reply rates were under 1%. I was blaming the copy.

The problem wasn’t the copy. It was the order I was doing things in.

Most teams do this:

Enrich → Personalise → Send → Wonder why it doesn’t work

The right order is:

Signal → Qualify → Enrich → Personalise → Sequence

One change. Everything improved.

Here’s the full process.

Read more

But here’s what became clear: the biggest impact AI is having right now isn’t in fancy automations. It’s in sales, marketing and advertising. Specifically, helping B2B businesses build predictable pipelines without hiring more SDRs or burning money on ads that don’t convert.

That’s where I’m focusing AIPoint in 2026: AI-powered sales and lead generation for B2B teams. Think signal-based prospecting, AI-personalised outreach, LinkedIn strategy, and multi-channel campaigns that actually book meetings.

This isn’t a random pivot. I’ve spent 20+ years in tech, built solutions for companies like Amazon, Pfizer, and AstraZeneca, and over the past 18 months, I’ve grown my own LinkedIn from 4K to 12K followers and booked hundreds of meetings using these exact systems. Now I’m packaging that for other businesses.

Two webinar recordings for you

I recently ran two webinars covering how AI is changing outbound sales and what B2B teams should be doing about it. If you missed them, you can watch the recordings here:

→ AI Outbound System in 2026

→ Build Your Own AI Sales Engine in 2026

Workshops & Masterclass

I’m also running hands-on workshops and a masterclass on AI for sales and GTM, built for founders, sales leaders, and revenue teams who want to learn how to set this up themselves.

If that sounds interesting, check out the details and register your interest here:

→ AI Outbound Masterclass - (2h session) - 27th March at 12 PM AEDT

→ AI Outbound Workshop - (4-week program - only 2/5 spots left) - 26th March at 3 PM AEDT

Or just reply to this email, and I’ll send you the info.

Talk soon,

Ima

As the year wraps up, here’s everything I built, learned, and shipped to help teams implement AI and automation:

• Joined the CSIRO program to learn how to build and scale a startup

• Pitched to investors, prospects, failed and pivoted

• Delivered consulting projects across stock trading, real estate, accounting, HR, marketing, and advertising

• Learned no-code and launched Growth Marketing Automation with n8n course on Udemy

• Published multiple end-to-end educational AI demos on my YouTube channel

• Spoke at 7 webinars (Some of the recordings are available here)

• Presented at 7 in-person events

• Met hundreds of operators, founders, and marketers trying to make AI practical in their teams

I spent the whole year testing digital marketing and sales outreach myself to understand what actually works.

Now, I’m doubling down on what B2B teams need most: connecting marketing, sales, and advertising data to generate qualified leads with AI.

What was your biggest learning in 2025?

#startup

Then I learned about n8n and thought: How long would it take to rebuild the same agent with no-code?

Turns out? Possible, but with tradeoffs.

What the agent does:

Analyzes stock or crypto trends by:

1. Fetching trending posts from multiple subreddits (r/StockMarket, r/WallStreetBets, r/cryptocurrency, etc.)

2. Scraping web data and Yahoo Finance

3. Using AI to analyze sentiment and generate investment insights with scores (-10 to +10)

The challenge: Loading trending posts from multiple subreddits for different tickers, especially when handling lists of data from third-party APIs.

Code vs. n8n: What I learned

In code (Python):

Pros

• Full customization, any logic you can imagine

• Fast data fetching from APIs

• Complex conditional logic is straightforward

Cons

• Takes longer to build

• Requires developer skills to maintain

In n8n (no-code):

Pros

• Much faster to build standard workflows

• Visual, easy to understand and modify

• Perfect for admin, marketing, and advertising use cases

Cons

• Slower when fetching large lists from third-party APIs

• Complex data transformations can get messy

The insight:

It’s all about use cases.

For this stock analysis agent with heavy API calls and complex data processing? Code wins.

But for marketing and advertising workflows, content repurposing, lead enrichment, social scheduling, and performance reporting? n8n speeds up the process significantly.

The prompt engineering behind it

Since prompting is crucial in AI engineering, here’s a peek at the prompt structure I used:

self.PROMPT_TEMPLATES = {
            “Web Agent”: ChatPromptTemplate.from_messages([
                (
                    “system”,
                    “”“
                    You are a senior analyst specializing in financial market research for both traditional assets and digital currencies.
                    Search the web to gather the most recent and relevant information.
                    
                    IMPORTANT: Your response MUST be valid JSON in this EXACT format:
                    [
                    {{
                        “symbol”: “<TICKER_OR_CRYPTO_SYMBOL>”,
                        “score”: <IMPACT_SCORE_NUMBER>,
                        “event_summary”: “<EVENT_SUMMARY>”,
                        “asset_type”: “<stock|crypto|unknown>”
                    }}
                    ]
                    
                    Rules:
                    - Score must be a number between -10 and +10
                    - For STOCKS: Focus on earnings, partnerships, regulatory changes, market sentiment
                    - For CRYPTO: Focus on adoption, regulatory news, technical developments, DeFi integration
                    - Identify asset_type as “stock”, “crypto”, or “unknown”
                    - Be concise but informative
                    - Return ONLY the JSON array, no other text
                    “”“
                ),
                (”human”, “{input}”),
                (”placeholder”, “{agent_scratchpad}”),
            ]),

            “Finance Agent”: ChatPromptTemplate.from_messages([
                (
                    “system”,
                    “”“
                    You are a senior finance analyst with expertise in both traditional markets and cryptocurrency analysis.
                    Use financial tools to analyze market data and trends.
                    
                    IMPORTANT: Your response MUST be valid JSON in this EXACT format:
                    [
                    {{
                        “symbol”: “<TICKER_OR_CRYPTO_SYMBOL>”,
                        “score”: <IMPACT_SCORE_NUMBER>,
                        “event_summary”: “<EVENT_SUMMARY>”,
                        “asset_type”: “<stock|crypto|unknown>”
                    }}
                    ]
                    
                    Rules:
                    - Score must be a number between -10 and +10 (-10 very negative, +10 very positive)
                    - For STOCKS: Include P/E ratios, revenue growth, dividend yield, market cap analysis
                    - For CRYPTO: Include price volatility, market cap, trading volume, blockchain metrics
                    - Identify asset_type based on the data source and characteristics
                    - Include quantitative data when available
                    - Return ONLY the JSON array, no other text
                    “”“
                ),
                (”human”, “{input}”),
                (”placeholder”, “{agent_scratchpad}”),
            ]),

            “Agents Team”: ChatPromptTemplate.from_messages([
                (
                    “system”,
                    “”“
                    You are a senior financial analyst coordinating comprehensive market research.
                    You analyze both traditional securities and digital assets with appropriate methodologies.
                    
                    CRITICAL: Always extract the ticker/symbol from the query and determine if it’s a stock or cryptocurrency.
                    Provide analysis appropriate to the asset type.
                    
                    MANDATORY OUTPUT FORMAT - Return ONLY this JSON structure:
                    [
                    {{
                        “symbol”: “<EXTRACT_TICKER_OR_CRYPTO_SYMBOL_FROM_QUERY>”,
                        “score”: <NUMBER_BETWEEN_-10_AND_10>,
                        “event_summary”: “<YOUR_ANALYSIS_SUMMARY>”,
                        “asset_type”: “<stock|crypto|unknown>”,
                        “analysis”: {{
                            “web_insights”: “<WEB_FINDINGS_CONTEXT_APPROPRIATE>”,
                            “financial_data”: “<FINANCIAL_OR_ONCHAIN_DATA>”,
                            “combined_analysis”: “<INVESTMENT_PERSPECTIVE_BY_ASSET_TYPE>”
                        }}
                    }}
                    ]
                    
                    ANALYSIS GUIDELINES:
                    FOR STOCKS:
                    - Focus on fundamentals: earnings, revenue, P/E ratios, market position
                    - Consider sector trends, competitive landscape, regulatory environment
                    - Evaluate dividend history, cash flow, debt levels
                    
                    FOR CRYPTO:
                    - Focus on adoption, technology developments, partnerships
                    - Consider tokenomics, staking rewards, governance changes
                    - Evaluate trading volume, market cap trends, DeFi integration
                    - Include regulatory impact and institutional adoption
                    
                    RULES:
                    1. ALWAYS extract symbol from query and determine asset type
                    2. Score -10 to +10: negative=bearish, positive=bullish, 0=neutral  
                    3. Provide analysis methodology appropriate to asset type
                    4. Return ONLY the JSON array - no other text
                    “”“
                ),
                (”human”, “{input}”),
                (”placeholder”, “{agent_scratchpad}”),
            ])
        }

The key: Structured output + clear rules + asset-type-specific guidance = consistent, actionable results.

Want the workflow template?

I’ve turned this into a Reddit Market Trend workflow template you can access in Agentic Lab.

What is Agentic Lab?

A hands-on community where we build real AI workflows together every week.

What’s inside:

• Live weekly sessions building workflows like this one

• Pre-built templates you can copy and customize

• Workflow reviews, I’ll help optimize what you build

• Integrations library (50+ marketing tool connection guides)

• Community of marketers and operators building alongside you

Next week we’re building: An Instagram trends workflow for content strategy

Not just watching, actually building together, troubleshooting, and deploying.

👉 Join Agentic Lab

Not ready? Grab the free Starter Kit with workflow templates.

Bottom line:

Choose your tool based on the use case:

• Heavy data processing + complex logic → Code

• AI automation + speed to deploy → n8n

Both have their place. The trick is knowing which to use when.

See you in the Lab,
Ima

P.S. If you’re curious about the full prompt templates or want to see the n8n version, they’re both available in the Lab’s workflow library.

Whether you’re a complete beginner or already working with AI tools, by the end of this guide you’ll know how to set up n8n, connect it to an AI model (like OpenAI), and create a working AI agent that performs real tasks.

By the end, you’ll know how to:

• Set up your n8n cloud environment

• Connect OpenAI (or any other model provider)

• Import starter templates

• Build and run your first AI workflows

Let’s dive in.

Step 1: Set Up Your n8n Environment

Head over to n8n.io and click Get Started.

• You’ll sign up for a 14-day free trial.

• After signing up, you’ll create a cloud environment.

  • This is where your workflows live.

  • Choose a name you’ll use consistently, since it will be part of your workspace identity.

Once inside, you’ll see the n8n dashboard, ready to host multiple workflows.

Step 2: Connect Your AI Model

Most people start with OpenAI, but you can also use providers like Mistral, Anthropic, DeepSeek, or Azure OpenAI.

For OpenAI:

1. Go to platform.openai.com.

2. Log in, then create a new secret key under your account settings.

3. Save the key somewhere safe, you’ll need it again.

4. In n8n, go to Credentials and store the API key there. This way, you can reuse it across workflows without re-entering it.

Step 3: Import Your Starter Workflow

To make things simple, the starter kit includes templates you can import directly:

1. In n8n, click the three dots on the right-hand side.

2. Select Import from file.

3. Upload the template file from your computer.

Now you’ll see a ready-to-use workflow. Let’s look at an example.

Example 1: Blog Summarizer

This workflow takes a blog link, fetches the content, and generates a summary.

• The AI node is set up with a prompt telling it to summarize the blog into JSON format.

• JSON output makes it easy to integrate the summary into other tools later.

When you run the workflow, n8n fetches the blog content, processes it through OpenAI, and returns a clean summary. You could even build a simple chatbot interface on top of this!

Example 2: Share Summaries with Your Team

Let’s take the Blog Summarizer one step further.

• After generating the summary, the workflow parses the JSON.

• Then it sends the output to a Discord channel (or Slack, or any team communication tool) using a webhook.

The result? AI-powered news or blog digests automatically posted for your team to read and discuss.

Example 3: Social Media Insights

Another workflow in the starter kit helps with content strategy:

• Input a brand name and industry.

• The AI agent finds common hashtags and trending posts.

• It analyzes the results and creates a creative brief with recommendations for future content.

• Finally, it can post the insights directly to your chosen channel.

This kind of workflow is a game-changer for marketing teams, saving time on research and giving you AI-powered direction.

Where to Go Next

This starter kit gives you the foundation to:

• Summarize content automatically

• Share AI insights with your team

• Generate creative briefs from social trends

From here, you can expand into more advanced automation tailored to your business.

If you’d like to go deeper, you can book my upcoming workshop (only 2 spots available), where we build complex workflows together.

And if you are unsure about attending the workshop, check out how Mafalda found the session.

Thanks for joining me on this journey. I can’t wait to see what you create with n8n and AI automation.

Step-by-step guide to implement an AI Agent in N8N

I will start with the simplest example: Create an AI agent that receives a URL in chat and scrapes the data from the website, then sends a summary of that.

First, create an n8n account (if you don’t already have one), then create a new workflow. In the new workflow, click on the + and type AI Agent on the right-hand side and drag the AI Agent to the page.

Now it’s time to add memory and an AI model to your AI Agent. First, choose an AI model and memory from the list of nodes and set up your credentials.

The next step is to add a prompt in your AI Agent so that the AI Agent can respond to the user accordingly.

Here is an example of the prompt that you can set in your AI Agent.

You are a concise web page summarizer. 
Given a URL, fetch it using the fetch_url tool, extract the main text, then respond in this JSON schema:

{
  "title": string,
  "summary": string,
  "key_points": [string, string, string],
  "suggested_next_action": string
}

Rules:
- Always call fetch_url exactly once per request.
- Ignore boilerplate (nav, footer).
- Keep summary under 120 words.
- If the page is non-text (PDF/image), still give a high-level summary from whatever text you can extract.
- If no URL is provided, ask for one and stop.

Now you are all set, you can click on “Open Chat“ to see the AI Agent in action and start sending website URLs that you want to see their summary.

The beautiful part about n8n is that you can see the execution in action

And here is the outcome:

The output is based on the prompt we set up.

{"title":"AIPoint - AI-Powered Solutions for Businesses","summary":"AIPoint offers AI-driven solutions designed to help businesses automate processes, enhance decision-making, and improve efficiency. The platform integrates advanced machine learning models to provide actionable insights and customizable AI tools tailored to various industries. It aims to empower enterprises to leverage artificial intelligence without extensive technical expertise.","key_points":["Provides AI-powered business automation tools.","Offers customizable machine learning integrations.","Targets enhanced decision-making and operational efficiency."],"suggested_next_action":"Explore AIPoint's product offerings and consider scheduling a demo to understand how their AI solutions can benefit your business."}	

If you want to see the output in a different format, such as text, you need to adjust the prompt in the AI Agent.

I’m running a small-group, hands-on AI Workflow Automation workshop in two weeks. We’ll go beyond simple AI Agent and design agentic workflows for SEO and real-world examples. If you are interested, click the banner to secure your spot.

AI SEO Assistant

Just built an AI SEO assistant in n8n that turns raw Google Search Console data into weekly insights.

No more spreadsheets.

No more spending 3–4 hours each week putting reports together (or paying a SEO analyst to do it).

Now I get:
- A quick summary of site performance
- CTR alerts for pages that rank but don’t get clicks
- Actionable recommendations per URL
- Discord alerts for every new update

It’s already saving me hours every week, and giving me the kind of insights I’d normally need an SEO analyst for.

👉 If you’d like to set this up for your own site, comment “SEO” and I’ll share the step-by-step instructions.

Context engineering is trending, but why?

Because prompts are no longer enough.

If you want your AI agent to do the thing, you need to feed it the right context, in the right format, at the right time.

That’s where Context Engineering comes in.

It’s not just about talking to an LLM; it’s about setting up the entire environment around it so it can make smart decisions.

Here’s what that looks like in practice:
🔰 The user input: What they’re asking
🔰 Chat history: The AI has memory
🔰 User data: Preferences, past behaviour, personalization
🔰 RAG context: Pulled from docs, websites, vector DBs
🔰 Tool access: APIs, search, calculators, whatever it needs
🔰 Reasoning: The agent can plan, reflect, and adapt
🔰And memory architecture:
Short-term → lives in the context window
Long-term → stored in your vector DB

Structured data beats raw blobs.

A clean prompt with scoped inputs beats a wall of unstructured info.

So when people ask me, “Why didn’t the AI do what I expected?”

It’s usually not the model.

It’s the missing context.

Prompting was the starting point.

Context is the system.

How are you handling context in your AI projects? Comment below 👇

Too many AI projects raise security concerns before they even start.

In this free webinar, I’ll walk through how to go from idea to implementation, safely and strategically, with real business impact.

Nick Fagan, Managing Director at Next Practice Management, will join me on this webinar to share how to strengthen your security posture while staying agile and compliant.

📅 Wednesday 20th Aug 10 am AEST
🔗 https://events.humanitix.com/ai-you-can-trust

If you're exploring AI for your business, this one's for you.

5 open-source frameworks to build AI Agents and workflows

If you're building AI agents and workflows, these 5 open-source frameworks will come in handy.

These tools give you visual control, LLM flexibility, and full observability, all without the black-box mystery.

🔰 Visual Workflows
Design logic on a canvas, no YAML, no black-box config.

🔰 Prompt-Level Control
Tweak prompts, tools, and model settings just like your LLM expects.

🔰 Model Switching
Run agents across OpenAI, Claude, Gemini, or Llama, no rewrites.

🔰 Built for Agents
Purpose-built for prompts, memory, tool calls, and reasoning.

🔰 Local to Cloud
Start with Ollama locally, scale to the cloud when ready.

🔰 Full Visibility
Track runs, latency, errors, and cost, all in one view.

Frameworks to Explore:
🔹 FlowiseAI (YC S23): A visual LangChain builder. Link: https://github.com/FlowiseAI/Flowise

🔹 Langflow: Simple UI for LLM workflows. Link: https://github.com/langflow-ai/langflow

🔹 AutoGen: Multi-Agent Framework for complex AI agent apps. Link: https://github.com/microsoft/autogen

🔹 Sim Studio (YC X25): Lightweight Agent Platform, built with minimal setup. Link: https://github.com/simstudioai/sim

🔹 WorkflowAI: An open-source platform where product and engineering teams collaborate to build and iterate on AI features. Link: https://github.com/WorkflowAI/WorkflowAI

Drop a comment if you’ve built with them, or if there’s another open-source tool we should check out!

Top 3 Low Code No Code Platforms

Since using AI tools, our team has shipped 40% faster to production.

Here's the interesting part: we didn't use AI to skip coding.

Instead, we used AI to amplify our development process. This lets our team focus on what matters most: architecture, user experience, and business logic.

These 3 platforms made the biggest difference:
🔰 n8n: Open-source and flexible, great for full control over data and logic
🔰 Make: Visual workflows that connect AI tools with simple drag-and-drop
🔰 Zapier: Fast automation for everyday apps and quick AI-powered wins

Whether it's automating hiring workflows, customer journeys, or business insights, these tools help you test, iterate, and scale faster than traditional development.

Any other tools that worked well for your product development? Share in the comments.

Top 5 AI Developer Assistants

Over the past year, we have used various AI tools to ship faster.

But how does that work for us?

We don't use AI tools for vibe coding, but rather for amplifying our development process, so, the team can focus on architecture, user experience and business logic.

Here are the top 5 AI Developer Assistants that help us to move fast in the market.

1. Buzzy Best for rapid mobile app development. Go from Figma design to app in minutes

2. Lovable Great for web development and SaaS with full stack support.

3. Copilot Powerful full stack developer assistant.

4. Amazon Q Knows everything about AWS infrastructure, no AWS certs are required.

5. Replit Lightweight cloud IDE for PoC development at the lowest cost.

What are your favourite AI development tools? Comment below 👇

Should we build an AI Agent for this?

A question came up multiple times during technical discussions this week.

Everyone keeps getting excited about AI Agents (totally get it!), but sometimes a simpler approach works better.

Here is my approach to when to use AI Agent and when don’t:

Use them when:
• You need judgment, not just clicks
• There’s too much data for humans
• The process is repeatable but flexible
• You want to personalize at scale

Skip them when:
• A simple script will do the work
• Accuracy is mission critical
• You don’t have clean data or context

AI isn’t magic, if we use it right, it’s a massive multiplier.

How do you approach implementing Gen AI solutions? Comment below.

We’re turning traditional hiring workflows into agentic workflows, powered by AI agents that streamline candidate evaluation, engagement, and management from start to finish.

If you're in hiring, recruiting, or talent acquisition, we’d love to demo what we’ve built and onboard you as one of our first users. Your feedback will directly shape the future of the platform.

Ready to see it in action? DM me or request a demo here.

Building with Lovable.dev

After throwing away multiple apps, I finally cracked the code for working with Lovable

Here's my proven workflow:
→ Write down what I want
→ Let ChatGPT polish it
→ Send the refined prompt to Lovable

Once I get the first version, I make all changes through small, incremental prompts.

IMPORTANT: No big changes or long prompts, they'll ruin everything.

Note: We handle backend integration ourselves. Lovable tries to push their preferred stack (like Supabase), but we prefer our solutions.

Key learning: Lovable eliminates the need for junior to mid-level front-end developers but emphasises the role of product designers.

What's your experience with AI development tools? Any workflows that have worked well for you?

Built an OCR AI agent on Replit in minutes

Did it work?
✅ Yes, it generated a fully functional AI agent.

Did it do what I asked?
❌ Not really, it gave me what it thinks is useful, not what I needed.

This is the paradox of accessible AI: We now have tools that let you build AI agents in minutes, not weeks.

But making them work for you?
That still takes time, context, and iteration.

According to Replit’s founder, 3 million AI apps have been created on Replit since last September when they announced Replent... Yet only ~300,000 are deployed live, which means less than 10%.

Why? Because building is easy. Serving real user needs is still challenging.

Comment below about your experience with other AI Agent builder platforms.

I like to hear about your experiences.

By the way, we have built the same AI Agent in-house and fully functional using Python, check out the case study here.

Here’s the thing: not all AI agents are created the same, and picking the wrong type can break your tools or make them unreliable.

Here’s a simple breakdown to help you use it right:
1. ZeroShotAgent (aka ZERO_SHOT_REACT_DESCRIPTION)
→ Simple, and fast, but only works with tools that take a single string input.
→ Suitable for: Basic calculators, and summarizers.
→ Not recommended for: Anything needing multiple arguments (like file_path + content).

2. StructuredChatAgent (STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION)
→ Lets you pass multiple named inputs (like JSON).
→ Works without OpenAI function-calling models.
→ Can be less reliable in argument parsing.
→ Great fallback for non-OpenAI models.

3. OpenAI Functions Agent (OPENAI_FUNCTIONS)
→ The gold standard for tool use.
→ Works with OpenAI models like GPT-4 Turbo and GPT-3.5 Turbo.
→ Translates natural language into structured arguments perfectly using function-calling.
→ Suitable for: Multi-step agents, workflows, or anything where your tools have complex inputs.

If you’re using GPT and building with Langchain, go with AgentType.OPENAI_FUNCTIONS. It’s reliable, clean, and works well with multiple tools and structured input.

What agent type has worked best for your projects? Comment below.

From Figma to Invoice Scanner AI Agent

We recently teamed up with Buzzy to turn a Figma design into a fully functional mobile app, complete with an AI backend that scans receipts, extracts key data, categorizes it using LLMs, and syncs it with QuickBooks.

→ Designed in Figma
→ Built front-end with Buzzy’s low-code platform
→ Powered by AI agents on AWS (OCR + categorization)
→ End-to-end: from upload to real-time data sync

This is what business-ready AI looks like:
→ Fast to deploy
→ Scalable
→ Customizable
→ Zero dev heavy lifting

Check out the full demo video here.

Let’s build smarter, not harder.

Live FAQ Assistant

Our FAQ Assistant is live, it’s designed to answer your questions about anything related to AIPoint.io. Check it out here.

The answer? Yes, with GenAI and a little magic from RAG (Retrieval-Augmented Generation).

We helped them build a smart FAQ assistant that connects all their fragmented knowledge sources, Discord threads, GitHub repos, website content, and S3 files, into a single conversational interface.

No need to manually centralize or rewrite docs.

Just ask a question → get an instant, accurate answer → from wherever that knowledge lives.
- Deployed on AWS
- Powered by GPT
- Integrated into their existing chatbot

This is what real GenAI integration looks like, not just another chatbot, but a context-aware assistant that knows where your stuff is.

If you are keen to learn how it works, check out the case study here.

Single-Agent RAG system vs. Multi-Agent RAG

When building a GenAI solution, a Single-Agent RAG system does everything:
→ Routes queries to a source (vector DB, web, Discord, etc.)
→ Retrieves info, reasons through it, and generates a response.

It works… until it doesn’t.

But there is a problem here, one agent doing everything means limited depth, no specialization, and harder debugging.

That’s where Multi-Agent RAG comes in:
→ A retriever agent finds relevant info
→ A reasoner agent validates and structures it
→ A responder agent crafts the final output
→ All with tool and API access as needed

The result:
✅ Better context = more accurate answers
✅ Modular logic = easier to maintain and extend
✅ Clear roles = less hallucination, more reliability

Think of it like a kitchen with prep cooks, a head chef, and a server.

One person trying to do it all? Chaos. A team working in sync? Michelin-level execution.

𝘪𝘮𝘢𝘨𝘦 𝘤𝘳𝘦𝘥𝘪𝘵𝘴: 𝘸𝘦𝘢𝘷𝘪𝘢𝘵𝘦_𝘪𝘰

Opensource MCP frameworks available across different languages

MCP (Model Context Protocol) is getting more popular as the standard for connecting AI agents to tools, APIs, and enterprise systems.

If you're working on AI agents, here's a list of opensource MCP frameworks available across different languages:

🔹 FastMCP by Jeremiah Lowin: A high-level framework for building MCP servers in Python. Link.

🔹 FastMCP by Frank Fiegel: A high-level framework for building MCP servers in TypeScript. Link.

🔹 LiteMCP A high-level framework for building MCP servers in JavaScript/TypeScript. Link.

🔹 mark3labs/mcp-go: Golang SDK for building MCP Servers and Clients. Link.

🔹 mullerhai/sakura-mcp: Scala MCP Framework for building effective agents with MCP servers and MCP clients shade from modelcontextprotocol.io. Link.

🔹 salty-flower/ModelContextProtocol.NET: A C# SDK for building MCP servers on .NET 9 with NativeAOT compatibility Link

🔹 quarkiverse/quarkus-mcp-server: Java SDK for building MCP servers using Quarkus. Link.

Whether you're working in Python, Java, C#, or even building on Solana, there’s an MCP tool for you.

If you know any other frameworks, please share in the comment.

ADK is Google’s flexible, modular framework for building and orchestrating AI agents, tightly integrated with the Google ecosystem and optimized for Gemini models.

With ADK, you can build everything from simple Gemini-powered assistants to complex, multi-agent workflows.

Here's a quick overview of the agents you can build:

LLM Agents

These are your reasoning engines, powered by LLMs for natural language understanding, decision-making, and tool use.

Example: Smart Email Assistant

class EmailReplyAgent(LlmAgent):

    def __init__(self):

        super().__init__(

            name="email_reply_agent",

            instructions="You're an assistant that drafts professional email replies.",

            tools=[GrammarCheckTool(), SummarizerTool()]

        )

Use Cases:

• AI customer support

• Email drafting

• Research summarization

• Tool-using agents (e.g., search + act)

Workflow Agents

Deterministic control agents that organize how other agents run:
SequentialAgent: Executes agents in specific order

Example: Onboarding Workflow

onboarding_agent = SequentialAgent(
    name="onboarding_sequence",
    sub_agents=[CollectUserInfoAgent(), SendWelcomeEmailAgent(), ScheduleIntroCallAgent()]
)

Use Cases:

• User onboarding

• Multi-step data pipelines

• Any fixed-sequence task

LoopAgent: Repeats a set of agents based on a condition

Example: Code Review Loop

loop_review_agent = LoopAgent(
    name="code_review_loop",
    sub_agents=[GenerateFixSuggestionAgent(), ApplyFixAgent()],
    max_iterations=3
)

Use Cases:

• Iterative refinement (e.g., code or content)

• Retry loops

• Model fine-tuning steps

ParallelAgent: Runs agents concurrently to save time
Example: Multi-Channel Content Generator

parallel_content_agent = ParallelAgent(
    name="content_creator_parallel",
    sub_agents=[BlogWriterAgent(), LinkedInPostAgent(), TweetAgent()]
)

Use Cases:

• Multi-format content generation

• Parallel data collection

• Independent tool execution

Custom Agents

For when you need total control. Define your own orchestration logic by extending the BaseAgent class.

Example: Conditional Routing Agent

class ConditionalAgent(BaseAgent):
    async def run(self, input_data):
        if input_data["priority"] == "high":
            return await HighPriorityAgent().run(input_data)
        else:
            return await LowPriorityAgent().run(input_data)

Use Cases:

• Conditional routing

• Multi-path workflows

• Domain-specific decision trees

  

  
  

ADK represents the next generation of AI tooling. If you’re looking to build with LLMs beyond chatbots, this is a framework worth exploring.

Github repo: https://github.com/google/adk-python

Sample ADK: https://github.com/google/adk-samples

AI Agents for real time market analysis and executing trading strategy

I recently built a multi-agent AI system that helps automate market analysis and trading signals, giving users smarter real-time insights while keeping them in control of AI recommendations.

Why use multi-agent AI for trading?
Multi-agent systems break down complex tasks into specialized agents.

Instead of a single AI trying to do everything, each agent focuses on a specific function, analyzing stock trends, tracking news, generating buy/sell signals, and even optimizing execution strategies.

Here’s how it works:
→ Analyzes real-time market data and trends 📊
→ Generates buy/sell signals for stocks 📈
→ Lets users approve or reject trades before execution
→ Once approved, executes trades using a smart strategy 🚀

This is a step towards the future of AI-assisted trading, where technology enhances decision-making, but you stay in control.

Watch the full video here.

Link to the github repository here.

Top 10 RAG and AI Agents Open Source Github repositories

If you're into AI agents, Retrieval-Augmented Generation (RAG), or workflow automation, you will find these repos helpful:

🔹 OpenManus: No need for an invite! This open-source library lets you use ManusAi features right away. GitHub link.

🔹 GenAI Agents by Nir Diamant: if you want to understand how AI agents work, this repo breaks down different techniques and approaches. GitHub link.

🔹 bRAG-Langchain: A deep dive into Retrieval-Augmented Generation (RAG) with hands-on examples. If you're building with RAG, this is a must-watch. GitHub link.

🔹 Awesome-LLM-as-a-Judge by Dawei Li and his folks: A well-curated collection of research on using LLMs to evaluate AI-generated content. Great for AI benchmarking. GitHub link.

🔹 Awesome-llm-apps by Shubham Saboo: A curated collection of awesome LLM apps built with RAG and AI agents. GitHub link.

🔹 FlowiseAI (YC S23), Drag & drop UI to build your customized LLM flow. Github link.

🔹 Dify is an open-source LLM app development platform: https://github.com/langgenius/dify

🔹 Helm is an open-source library for Holistic Evaluation of Language Models: https://github.com/stanford-crfm/helm

🔹 Langflow is a powerful tool for building and deploying AI-powered agents and workflows https://github.com/langflow-ai/langflow

🔹 LLM4Annotation is an open-source library for Large Language Models for Data Annotation and Synthesis: https://github.com/Zhen-Tan-dmml/LLM4Annotation

If you're building with AI, these repos can save you time and help you build faster.

If you know any other helpful open-source AI projects, drop them in the comments, I’d love to check them out! 🚀

Software architecture is constantly evolving, and AI systems are reshaping how we think about scalability, efficiency, and design.

While microservices have been the dominant approach for past few years, there's growing interest in modular architecture, especially for AI workloads.

Microservices introduced key advantages:
→ Independently deployable components
→ Technology-agnostic development
→ Isolated data stores
→ API-based communication

But as AI systems scale, some challenges become apparent:
→ Increased network latency
→ Complex inter-service communication
→ High operational overhead


Modular architecture takes a different approach:
→ Logical boundaries instead of strict isolation
→ In-process communication for efficiency
→ Shared resource management
→ Optimized for complex workflows


Key Differences
→ Communication: Microservices rely on network-based API calls, while modular architecture enables more flexible, in-process interactions.
→ Data Management: Microservices often use distributed, service-specific databases, whereas modular systems manage data centrally.
→ Performance: Microservices can introduce latency in cross-service operations, whereas modular designs reduce overhead and improve responsiveness.


As we start building more AI workloads, we realized AI workloads require:
→ Seamless model interactions
→ Low-latency workflows
→ Dynamic component composition
→ Efficient resource utilization

This shift doesn’t mean microservices are obsolete, it’s about choosing the right architecture for the right problem.

AI systems, with their need for fast, interconnected processing, are driving the move toward modularity.

What's your experience with these architectures in your projects? Comment below!

Top Vibe Coding platforms

Coding used to be all about syntax and debugging.

Now, it’s about flow, creativity, and AI-powered tools.

A new wave of "vibe coding" platforms is changing how we build application, where AI collaborates with us instead of just following instructions.

Here are some of the low-code, no-code, and AI-assisted development to help you go from idea to product faster than ever.

Some of my favorites:
Buzzy: Turn Figma designs into working apps.
Lovable: AI-first, drag-and-drop, beautifully designed.
Cursor: AI-powered coding assistant, great for teams.
Retool: The go-to for building internal AI-powered tools.

And for AI workflow automation:
Make: Visual workflow builder with deep AI integrations.
Zapier: Connect AI models to 6,000+ apps with no code.
n8n: Open-source, self-hosted automation for AI-heavy workflows.

These tools don’t just make things faster, they make building feel better.

💡 Have you tried any of these? What’s your go-to for AI-driven development?

Predictive AI vs Generative AI

AI is reshaping trading. But not all AI works the same way.

Predictive AI helps traders:
→ Analyze market trends
→ Forecast price movements
→ Backtest strategies using historical data.

It powers algorithmic trading but relies on past data, which limits its adaptability in unpredictable markets.

Generative AI has changed the game. It generates:
→ Synthetic data for testing
→ Simulates market conditions beyond historical trends
→ Enhances risk assessment.

In short, it helps traders prepare for scenarios predictive models can’t see.

🔹 Predictive AI → Identifies patterns and opportunities
🔹 Generative AI → Stress-tests strategies and simulates market shifts
🔹 Together → More robust, adaptive trading systems

Markets evolve, so, strategies should too and AI makes that possible.

How do you see AI shaping the future of trading? Comment below.

Have you ever wondered how different Agentic frameworks handle AI agents? Here's a quick guide to some of the popular ones:

LangChain
→ Component-based architecture focused on chains
→ Modular design connecting LLMs, memory, and tools
→ Great for building sequential workflows and basic agent interactions

LangGraph (LangChain's sibling)
→ State machine-based architecture
→ Explicit workflow control with graph structures
→ Perfect for complex, non-linear processes with multiple decision points

AutoGen
→ Multi-agent conversation architecture
→ Agents can autonomously collaborate through chat
→ Excels at complex problem-solving through agent-to-agent communication

CrewAI
→ Role-based team architecture
→ Simulates human team structures (like researcher, writer, reviewer)
→ Built for complex tasks requiring multiple specialized agents

Agno (formerly Phidata)
→ Application-centric, assistant-based workflows
→ Scalable, production-ready AI application orchestration
→ Function-based tool system for enterprise-level tasks

These frameworks are each great in different scenarios:
Need a basic LLM app? → LangChain
Complex, multi-step workflows? → LangGraph
Multi-agent collaboration? → AutoGen
Sequential tasks simulation? → CrewAI
Task automation focus? → Agno

Comment below which one you work with 👇

Why does LLM observability matter?

RAG applications and AI Agents come with complex reasoning chains, and errors can occur at any stage, from embedding to API calls and tool calls. This is why LLM observability tools are crucial for:

→ Troubleshooting issues
→ Performance monitoring
→ Prompt optimization
→ Hallucination detection
→ Cost optimization

Some popular LLM observability tools at the moment include LangSmith and Helicone (YC W23). What other tools do you use for LLM tracing and monitoring? Comment below 👇

Install DeepSeek on AWS Cloud

DeepSeek is now available for deployment on Amazon Web Services (AWS).

If you want to install DeepSeek on Ollama, Google Colab, or AWS, I’ve put together a video guide covering:
→ Installing DeepSeek on Ollama (local setup)
→ Running it on Google Colab (cloud-based)
→ Deploying it on AWS (scalable solution)

Which setup is best for you? I compare them in this video, so you can choose the right one!

📌 Check out the full video here.

Compare Two Foundation Models on Amazon Bedrock Playground and SageMaker Playground

If you caught my previous post on how to install DeepSeek on AWS Cloud, here is a quick video on how to compare two foundation models on Amazon Bedrock Playground and SageMaker Playground.

Choosing the right foundation model for your project is always important, so, consider these key factors such as:
→ Business use cases
→ Cost
→ Latency
→ Accuracy
→ Hardware requirements

Check out the full video here.

When I first explored running an in-house LLM, I was surprised by the operational costs such as energy consumption and expenses of GPU usage.

Here is a breakdown of when it makes sense to run your own LLM:

✅ High-volume API usage: If your company makes millions of API calls per month, API fees can go high significantly. Then running an LLM in-house might become cheaper in the long run.

✅ Existing Infrastructure: If your company has GPU infrastructure for existing AI/ML tasks, adding an LLM might not be an issue.

✅ Continuous API Costs: OpenAI and all other APIs charge per request. If an in-house model can handle the same workload efficiently, it eliminates these ongoing fees.

Don't run your own LLM if you want to prevent:

❌ Expensive hardware & cloud costs: Renting high-end GPUs from AWS, Azure, or GCP can be very expensive. On-premises GPUs require large upfront costs and maintenance.

❌ Operational complexity: Managing updates, security patches, and scaling the model requires an in-house team. API providers handle this for you at no extra cost.

❌ Energy consumption: Running an LLM 24/7 has huge electricity and cooling costs, which businesses might not consider in the first place.

Let's explore an example here:

If you want to run your own LLM on AWS Cloud, you need to use a GPU instance that can handle high-volume API calls. So the approximate costs will be as below.

Note: I included two instances one for only running LLM and one for running and fine-tuning tasks.

In the table below I compared three AWS GPU instances costs for only running LLM or for combined LLM and fine-tuning tasks. As you can see the cost of usage increase three times if you have high volume API usage from ~$547 to $1470 and if you additionally want to run fine-tuning, it costs $17870.

As you can see the cost is high significantly for running one GPU instance to handle API calls to an in-house LLM.

What’s your decision on running in-house LLMs? Comment below or DM me to discuss this further.

Run DeepSeek locally in 5 mins

If you want to control and customize your LLM, here is a quick guide to install DeepSeek locally. This will allow you to experiment with and own your LLM for future use.

In this guide, you will learn:
🔹DeepSeek model comparisons
🔹Install Ollama
🔹Run DeepSeek-R1 on Ollama
🔹 Run DeepSeek-R1-Distill-Qwen-1.5b (Faster and Smaller) on Google Colab

DeepSeek Models Comparison

Steps to Run DeepSeek-R1 On Ollama

• Install Ollama (if you haven’t already)

  For Linux users:

  

  Other OS: Download Ollama here.

  For Mac users:

  

  

• Pull Deepseek-R1

  

  Once Ollama is installed, open the Command Line Interface (CLI) and pull the model:

• Run the model

  Now you can run the model

Once the model is available, you can ask any questions and it will reply you with no issue.

Steps to Run DeepSeek-R1-Distill On GoogleColab

• Go to Google Colab

  a. Create a new notebook
  b. Set the Runtime to GPU/TPU by choosing Runtime type

  (GPU is generally recommended)

• Install Python libraries

In the new notebook, run the following command

• Download and load the Deepseek model

  Now you can download and load the model and run some experiment.

Check this out and comment below or DM me if you need assistance with production use cases.

What is a Multi-Agent AI System?

A multi AI Agents system is a technique where multiple AI agents, each with a specific role, work together to achieve a common goal. Think of this as a team of experts: one agent might gather data, another analyzes trends, and a third synthesizes insights. By dividing tasks among specialized agents, the system becomes faster, more accurate, and more efficient.

In this project, I created three agents that use different LLM models:

1. Web Agent: It uses the Open AI GPT-4o model and searches the web for real-time news and public sentiment using DuckDuckGo.

2. Finance Agent: It uses the Open AI GPT-4o model to analyse financial data, such as stock prices and analyst recommendations, using Yahoo Finance.

3. Grok Agent: It uses XAI (grok-beta) to combine web insights and financial data which provide a comprehensive analysis.

   

These agents are orchestrated by a AI Agents Team as demonstrated in the picture. The Agents team manage the collaboration among AI Agents and delivers a unified, actionable report.

How a Agent works in Phidata?

• User Query: The user asks the question

• Query Analysis: The agent interprets the query to formulate a search strategy

• Web Search: When given a query, the agent uses its search tool (DuckDuckGo here) to find relevant information on the web.

• Data Processing: The agent then processes the search results, summarizes the information, and provides a response to the user.

• Dynamic Response: The response is typically formatted in markdown and can be streamed to the user for real-time feedback.

Database in Phidata

When using phidata, agent sessions will be stored in SQLite format in the agents.db file on the application side. Here's how this works:

1. SqlAgentStorage is used to store agent sessions in a SQLite database.

2. The database file is typically named agents.db or something similar.

3. It's used to maintain the persistence of agent interactions across sessions.

Why Use Multi-Agent Systems for Financial Analysis?

The financial industry is complex, with data coming from multiple sources—news, social media such as x.com, stock prices, and more. A single AI model might struggle to handle this complexity, but a multi-agent system performs well. Here’s why:

• Specialization: Each agent focuses on what it does best which guarantees high-quality results.

• Efficiency: Tasks are divided and processed in parallel to save time.

• Scalability: You can easily add more agents to handle additional tasks or data sources.

For example, if you want to analyze the impact of a recent news event on a company’s stock price, the Web Agent can gather the latest news, the Finance Agent can analyze stock trends, and the Grok Agent can combine these insights into a clear, actionable summary.

How I Built the Multi AI Agents system

Here’s a high-level overview of the steps I followed:

1. Set Up the Agents:

   • Each agent was created using Phidata library and specialized tools like DuckDuckGo for web search and Yahoo Finance for financial data.

   • The agents were designed to output their findings in a structured JSON format for easy integration.

     web_agent = Agent(
             name="Web Agent",
             role="Searching the web for real-timeabout companies, and public sentiment.",
             model=OpenAIChat(id="gpt-4o"),
             tools=[DuckDuckGo()],
             instructions=["Search for the latest news articles, social media trends, and public discussions related to the user's query.\n" +
                         "Respond in JSON format only, no additional text" + 
                         "{['symbol': 'The company stock ticker','score': Impact estimation (-10 to +10) based on the company stock price.,'event_summary': 'A brief description of the event.'}]}"],
             storage=SqlAgentStorage(table_name="web_agent", db_file="agents.db"),
             add_history_to_messages=False,
             markdown=False,
         )
     
     
         finance_agent = Agent(
             name="Finance Agent",
             role="Accessing and analyzing financial data and trends from structured finance databases.",
             model=OpenAIChat(id="gpt-4o"),
             tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
             instructions=["Use financial tools (e.g., Yahoo Finance) to gather stock prices, company-specific news, and analyst recommendations.\n" +                
                         "Respond in JSON format only, no additional text:\n" +
                         "{['symbol': 'The company stock ticker','score': Impact estimation (-10 to +10) based on the company stock price.,'event_summary': 'Include quantitative data relevant to the user query.'}]}"],
             storage=SqlAgentStorage(table_name="finance_agent", db_file="agents.db"),
             add_history_to_messages=False,
             markdown=False,
         )
     
         grok_agent = Agent(
             name="Grok Agent",
             role="Combining web search and x.com data.",
             model=xAI(id="grok-beta"),
             tools=[DuckDuckGo()],
             instructions=["Use both web tools and x.com public tweets to gather a comprehensive view of trends, and sentiment.\n" +                    
                         "Respond in JSON format only, no additional text:\n" +
                         "{['symbol': 'The company stock ticker','score': Impact estimation (-10 to +10) based on the event's likely effect on the company stock price.,'event_summary': 'Combine news and data.'}]}"],
             show_tool_calls=False,
             markdown=False,
         )

2. Orchestrate the Team:

   • The Team Agent coordinates the tasks of the Web Agent, Finance Agent, and Grok Agent.

   • It merges their outputs, removes duplicates, and generates a final report.

     agent_team = Agent(
             team=[web_agent, finance_agent, grok_agent],
             name="Agents Team",
             role="Orchestrating tasks across specialized agents to produce the most accurate and comprehensive responses.",
             instructions=["Delegate tasks based on prompt requirements:\n" +
                         "Web Agent: For real-time news and sentiment analysis.\n" + 
                         "Finance Agent: For financial data and analytics.\n" +
                         "Grok Agent: For tunring insights into a well-structured response.\n" +        
                         "Respond in JSON format only, no additional text:\n" +
                         "{\n" +
                         '   "symbol": "TICKER",\n' +
                         '   "score": NUMBER_BETWEEN_NEGATIVE_10_AND_10,\n' +
                         '   "event_summary": "SUMMARY",\n' +
                         '   "analysis": {\n' +
                         '       "web_insights": "WEB_FINDINGS",\n' +
                         '       "financial_data": "FINANCIAL_METRICS",\n' +
                         '       "combined_web_analysis": "SYNTHESIS"\n' +
                         "    }\n" +
                         "}\n" +                    
                         "Deduplicate or reconcile overlapping findings.\n" +
                         "Provide a clear, actionable summary for the user."],
             show_tool_calls=False,
             markdown=False,
         )

3. Create a User Interface:

   • Using Streamlit, I built a simple interface where users can input queries and select which agent or team to use.

     # Streamlit App
         st.title("AI Agent Finance Team")
         st.write("Interact with your AI agents to get financial data and web search results.")
     
         # User input
         user_query = st.text_input("Enter your query:")
     
         # Dropdown to select the agent
         agent_selection = st.selectbox(
             "Select an Agent",
             options=["Web Agent", "Finance Agent", "Grok Agent", "Agents Team"],
         )
     
         # Agent map
         agent_map = {
             "Web Agent": aiAgentFinanceTeam.web_agent,
             "Finance Agent": aiAgentFinanceTeam.finance_agent,
             "Grok Agent": aiAgentFinanceTeam.grok_agent,
             "Agents Team": aiAgentFinanceTeam.agent_team,
         }
     
         if st.button("Submit Query"):
             if user_query.strip():
                 selected_agent = agent_map[agent_selection]
                 prompt = aiAgentFinanceTeam.generate_prompt(selected_agent.name, user_query)
                 response = selected_agent.run(user_query)
     
                 try:
                     # Process response and send to Discord
                     response_content = aiAgentFinanceTeam.process_and_send_response(
                         response,
                         selected_agent.name
                     )
                                     
                     
                     # Debug: Show extracted text
                     st.write("Extracted text:")
                     st.write(response_content)
                     
                     # Show Discord status
                     st.success("Results sent to Discord successfully!")
                     
                 except Exception as e:
                     st.error(f"Error processing response: {str(e)}")
                     st.text("Raw response:")
                     st.text(response)
             else:
                 st.warning("Please enter a query before submitting.")
     

What did I learned?

• Prompt Template is key

  It is important to define the right prompt template for your usecases to be able to get the right outcome.

  "Web Agent": """
      Objective: Use web search to gather the most recent and relevant information on publicly traded companies based on the query.
  
      Required Format (JSON):
      [
      {{
          "symbol": "<COMPANY_TICKER>",
          "score": <IMPACT_SCORE>,
          "event_summary": "<EVENT_SUMMARY>"
      }}
      ]

• Instructions is essential in Phidata

  Instructions are important in Phidata as they are used alongside the "description" parameter to build the system prompt sent to the language model.

• Define the Response Format

  To receive the right output, you need to define the response format correctly, whether it is a JSON or text or html and so on.

  {['symbol': 'The company stock ticker','score': 'Estimation betweebn (-10 to +10)'}

Why Multi AI Agents are the the next big thing?

Multi-agent AI systems aren’t just a technical fancy technique, they’re a game-changer for industries like finance, healthcare, and logistics. By automating complex tasks, they free up time for strategic decision-making and innovation.

Whether you’re a developer, data scientist, or finance professional, learning to build multi-agent systems can give you a competitive edge in the world of AI.

Don’t forget to subscribe to my newsletter for more tutorials, insights, and updates on AI and technology.

The interest in building AI agents and LLM-based solutions is increasing rapidly. After exploring various solutions I noticed that not only do the principles of traditional software development apply, but AI agents require additional layers around security, scalability, and cost efficiency. Here's a detailed guide on what it takes to build a robust AI agent architecture.

1. Cloud Infrastructure Foundations

Before diving into AI-specific concerns, we must ensure that your cloud infrastructure follows the best practices. These include:

• Infrastructure as Code (IaC): Use tools like Terraform or AWS CloudFormation to maintain version-controlled, repeatable infrastructure setups.

• Monitoring and Logging: Implement comprehensive observability like AWS CloudWatch, Datadog, or Grafana. Logs and metrics are important tools for diagnosing performance issues.

• Scalability: Ensure horizontal scaling capabilities through auto-scaling groups, Kubernetes clusters, or serverless functions.

• High Availability: Design multi-AZ or multi-region architectures to minimize downtime.

2. Enhanced Security for AI Agents

AI agents usually handle sensitive business data and issue commands to critical systems. This requires applying security measures:

• Data Encryption: It’s important to encrypt data at rest and in transit. Use managed key services like AWS KMS for encryption management.

• Secure API Gateways: If you expose your AI agents to other services, expose them through secure API endpoints. Leverage API Gateway services with strong authentication and rate-limiting policies.

• IAM Policies: Implement the principle of least privilege. AI agents and related services should only have access to the resources they need.

• VPC Design: Place AI services in private subnets and control external access via bastion hosts or VPN connections.

• Audit Trails: Enable logging for all access to sensitive resources. Services like AWS CloudTrail or Azure Monitor can help track interactions.

• LLM Model Isolation: If using third-party LLMs like OpenAI’s API, ensure that API keys and other credentials are securely stored and rotated periodically.

3. Performance Optimization for AI Agents

AI agents often process large datasets and require low-latency access to models or APIs. Optimize performance by:

• Model Hosting: If hosting models locally, use optimized GPU instances like AWS’s p4d or Azure’s ND-series. For serverless deployments, consider containerizing models with FastAPI or LangChain.

• Caching: Use in-memory databases like Redis or Memcached to cache frequent queries or intermediate results.

• Batch Processing: For high-throughput tasks, batch input requests minimize inference overhead.

• Edge Deployment: When there is a need for low latency, deploy AI agents closer to end users via edge computing platforms like AWS Lambda@Edge or Cloudflare Workers.

4. Cost Management

AI workloads can quickly become costly without careful planning. To control costs usage:

• Spot Instances: Use spot or preemptible instances for non-critical workloads.

• Usage Tracking: Implement cost monitoring tools like AWS Cost Explorer or Azure Cost Management.

• Serverless Functions: Use serverless for on-demand usage scenarios, especially for smaller AI agents.

• Optimize Model Size: Fine-tune smaller LLMs when possible instead of relying solely on large, expensive base models.

5. Observability and Feedback Loops

AI agents must be transparent in their operations and provide actionable feedback for improvement.

• Traceability: Log all decisions and interactions for debugging and regulatory compliance.

• Metrics and Alerts: Track key metrics such as request latency, model inference time, and error rates.

• Feedback Mechanisms: Build workflows to collect user feedback and retrain models periodically to improve AI agent performance.

6. Regulatory Compliance and Ethical Considerations

AI agents are subject to the same regulatory frameworks as other software—and sometimes more restrictive ones.

• Data Residency: Ensure compliance with data residency laws (e.g., GDPR, CCPA) by using region-specific resources.

• Bias Mitigation: Regularly test and mitigate model bias using standardized datasets and explainability tools.

• Security Certifications: Pursue certifications like ISO 27001 or SOC 2 for your cloud infrastructure.

7. Key Frameworks and Tools for AI Agent Development

Several frameworks can help streamline the development and deployment of AI agents:

• LangChain and LangGraph: Useful for orchestrating LLMs in complex workflows.

• Ray: For distributed computing and scaling AI workloads.

• FastAPI: Ideal for creating lightweight APIs for your AI agents.

• AWS Bedrock: Offers managed LLM services to simplify inference.

• Docker and Kubernetes: Containerize your agents for consistency across development and production environments.

Conclusion

While building a robust AI agent architecture, it is important to approach the task with an approach that balances scalability, security, and cost efficiency. Most of the principles remain the same as traditional software development.

By implementing these best practices, you’ll be well-positioned to deliver reliable and secure AI agent solutions that meet the demands of modern businesses. Remember, the extra effort to secure and optimize your infrastructure now will pay for it in performance and trust down the road.

Over the last few months, I've been working with Amazon Bedrock's Agents, and I wanted to share how these AI agents actually work on AWS. Here's a breakdown of the key components that make it all happen:

🔹 Foundation Models: Amazon Bedrock agents use various foundation models like Claude, Amazon Titan and more.
🔹Knowledge Bases: The Agent's Memory consider the knowledge bases as the agent's long-term memory. You can upload documents, FAQs, and other resources that the agent can reference. Using RAG (Retrieval Augmented Generation), agents pull relevant information from these knowledge bases to provide accurate, contextual responses.
🔹Action Groups: They're collections of API operations that agents can execute. Action groups let agents interact with your existing systems and APIs securely.
🔹Guardrails: AWS has built-in guardrails that act as safety net for agent behavior. These include: Input/output filtering, Prompt engineering controls, API call limitations, Authentication and authorization checks.

Orchestration Layer behind the scenes:
🔹Message routing and tracking
🔹Context management
🔹State persistence
🔹Error handling and retries

💡 Pro Tip: When building agents, start small. Begin with a focused knowledge base and a limited set of actions. It's easier to expand capabilities gradually than to debug a complex system.

🔑 Key Benefits:
🔹Reduced development time for AI applications
🔹Consistent security and governance
🔹Native integration with AWS services
🔹Scalability and reliability out of the box

Have you worked with Amazon Bedrock agents? What has been your experience? Comment below 👇

In this post, I decided to simplify AI Agent concepts for software engineers by comparing AI Agents with Microservice Architecture to make it easier for fellow software engineers to start working on AI projects. Keep in mind that a multi AI Agents architecture could be designed differently depends on various use cases.

So, here’s a simplified comparison of AI Agent Architecture’s components for software engineers:

• Modular Architecture ↔ Microservice Architecture: Both architectures emphasize modular, independent components that work together efficiently.

• AI Agent ↔ Service: An AI agent operates like a service that handles specific tasks autonomously, similar to microservices but AI agents can decide on their own with added intelligence and adaptability.

• Task ↔ Function: Each task in an AI agent is similar to a function/method in a microservice.

• Tool ↔ APIs or Microservices: Tools in AI agents are comparable to APIs or even other microservices that enable interaction with external systems or services.

• Short Memory ↔ Caching: Short-term memory is a temporary storage for quick retrieval, similar to caching.

• Long Memory ↔ Database Storage: Long-term memory provides persistent storage, much like databases (SQL and No SQL).

• Fine-Tuning and RAG ↔ Domain-Specific Services: Fine-tuning and RAG make AI agents domain-specific, similar to domain-specific microservices.

• Multi-Agent System ↔ Microservice Architecture: A network of agents mirrors a distributed microservice architecture.

• Infrastructure & Cloud: AI Agents and Microservices rely on scalable cloud solutions for deployment and maintenance.

• Queue & Notifications: Task coordination in AI systems uses queues and notifications, just like in event-driven and microservice architectures.

• Vector Database (New Database Paradigm): Vector databases store embeddings for similarity search, offering a new approach to data retrieval.

Additional Concepts for AI Agents and Microservices

• Orchestration (e.g., LangChain or LangGraph): LangChain and LangGraph orchestrate AI workflows at the application level. They coordinate interactions between agents and tools. For infrastructure orchestration, Kubernetes can still be used to manage containerized AI agents.

• Observation & Feedback Loops: Agents can learn or adapt dynamically via feedback loops, while traditional microservices lack.

• Autonomy vs. Predefined Logic: AI agents have decision-making autonomy, leveraging machine learning models, whereas microservices execute predefined logic.

• Security & Governance: AI agents may require additional considerations for ethical AI, prompt injection attacks, and hallucinations. These are not typical concerns in microservice architectures.

• Cost Management: Cloud costs for AI agents can be higher due to LLM inference, embedding queries, and GPU/TPU requirements.

If you found this post helpful, feel free to share it with your team and help everyone learn and adapt to AI.

AI agents are changing the way we apply automation, decision-making, and collaboration. If you're looking to start building AI agents, here’s a compiled list of frameworks organized by their use cases to guide you:

1️⃣ Development Platforms & Core Infrastructure
These platforms provide the building blocks for agent development and setting up the core infrastructure:
▪️ LangChain: A full-featured platform for building complex multi agent workflows, connecting LLMs with tools, APIs, and memory.
▪️ Semantic Kernel: This framework is ideal for enterprises which enables sophisticated agent design with advanced orchestration capabilities.
▪️ LlamaIndex: Specialized in connecting and retrieving data, making it a must-have for knowledge-driven agents.
▪️ AutoGen: Automates the creation of code, workflows, and tasks from high-level instructions, streamlining the development process.

2️⃣ Autonomous Task Execution
There frameworks focuse on task automation and execution:
▪️ AutoGPT: A versatile tool for general-purpose task execution with autonomous capabilities.
▪️ PhiData: Simplifies task automation and workflow orchestration for repetitive processes.
▪️ Letta: A robust framework for orchestrating workflows and automating tasks across domains.

3️⃣ Multi-Agent Orchestration
These frameworks are designed for managing collaboration between multiple agents:
▪️ CrewAI: Enables role-based agent collaboration, making it easy to define responsibilities and interactions.
▪️ ️LangGraph: Facilitates complex decision-making with a framework for coordinating multiple agents effectively.

4️⃣ Specialized Agent Systems
Tailored for specific applications:
▪️ DSPy: Leverages prompt programming and chain-of-thought reasoning to create intelligent agents.
▪️ Agent Protocol : Focuses on standardization and interoperability to integrate agents seamlessly.

Ready to explore?
Check out these frameworks and see how they can transform your projects. Have you used any of these? Let me know your thoughts, or reply if you need help choosing the right one for your needs!

This is the written version of my talk at GEEQ meetup in Sydney, Australia on 5th December 2024. I tried to write down as much as I remembered for anyone who is keen to learn about Chatbots and beyond.

In 2015-2016, chatbots were the new trend in tech. Considering the state of tech, we can call them traditional chatbots. During that time, I built a customer support chatbot for Gumtree Australia (part of eBay Classifieds Group). I used Apache NLP and Java to develop a microservice-based chatbot and trained the model with customer support data pulled from Gumtree’s data warehouse.

Here’s how the chatbot worked: the chatbot broke down customer enquiries using NLP techniques like tokenization, part-of-speech tagging, and parsing. It then selected the best possible response based on the highest confidence score. The training data focused on four key categories: SCAM, SMS Fraud, Report Ads, and Accounts which were common support issues on the platform.

The architecture was straightforward: a backend and a frontend microservice, a datastore for storing the training models. The chatbot was rule-based and limited to specific use cases. But even with these limitations, chatbots started gaining traction. Why? Because they solved real business problems.

Why Chatbots Became Popular

Here’s what made traditional chatbots popular:

• 24/7 Availability: Customers could receive support at any time, no matter the timezone.

• Cost Efficiency: Companies could reduce their customer support team size by delegating repetitive inquiries to chatbots.

• Scalability: Unlike humans, chatbots can handle multiple conversations simultaneously, especially during peak times.

• Faster Responses: No more waiting for a consultant—chatbots offer instant replies.

• Easy Integration: Chatbots could be integrated into any platform such as Facebook Messenger, WhatsApp, or Slack.

But there were limitations to traditional chatbots:

• Static Rules: They could only respond to the static rules they were trained with.

• Limited Understanding: Due to the basic NLP capabilities and static rules, chatbots could provide incorrect responses.

The Rise of ChatGPT and Large Language Models

In 2022, ChatGPT was released and suddenly everything changed—not just for chatbots, but in how we solve problems with technology.

ChatGPT introduced the concept of Large Language Models (LLMs). Unlike traditional chatbots, LLMs don’t rely on static rules. Instead, they are pre-trained on massive datasets and leverage neural network algorithms to understand language at a much deeper level. With millions of parameters, they can generate dynamic responses. Therefore, chatbots moved from purpose based interaction to context aware conversations.

This was a game changer for chatbots, they were no longer limited to answering FAQs—they could now generate new content, and understand complex inquiries from customers. As ChatGPT became more and more popular, an interest arose in how to leverage chatGPT in various business use cases. Here is a simple technical architecture demonstrating on how to leverage foundation model in a chatbot service to allow ChatGPT like chatbot.

Domain-Specific Chatbots using Fine-Tuning and RAG

While LLMs have a big advantage over NLP, they lack domain-specific knowledge. So, it was important to utilize LLMs for a specific industry.

Because of that two key techniques emerged:

1. Fine-Tuning

2. RAG (Retrieval-Augmented Generation)

Now, let’s break them down each here.

1. Fine-Tuning

Fine-tuning involves training an existing LLM with domain-specific datasets. For example, a legal chatbot might be fine-tuned using legal documents, allowing the chatbot to provide accurate, context-aware responses to legal inquiries. The following diagram demonstrate how fine tuning can be implemented for an AI Chatbot.

Benefits:

• Customization for specific industries (e.g., healthcare, legal, customer support).

• Improved response quality within a specific domain and industry.

Challenges:

• Frequent model training is required to keep up with industry updates or regulatory changes.

• Costly due to repeated model training performed by the tech team

• The risk of hallucination in case of using massive datasets (i.e., generating inaccurate or irrelevant information).

2. Retrieval-Augmented Generation (RAG)

RAG takes a different approach. Instead of relying only on pre-trained knowledge, it dynamically fetches information from external data sources. RAG architecture is based on a retriever and a generator. Here’s how RAG works:

• The retriever pulls relevant data from sources similar to databases, documents, or websites.

• The generator uses that data to craft accurate, up-to-date responses.

Benefits:

• Access to dynamic, real-time knowledge.

• No need for repeated model training.

• Cost-effective and scalable.

Challenges:

• Potential latency due to fetching external data.

• Data quality and risk of biases.

• Security and privacy concerns when accessing sensitive data.

AI Agents: Chatbots who act

The idea of AI agents is to give chatbots a more autonomous role. Chatbots don’t just respond to prompts; they set goals, execute tasks, and handle unexpected scenarios. For example, in customer service, an AI agent could process a refund, send a confirmation email, and schedule follow-ups—all without additional commands.

AI agents leverage Language-Aware Models (LAMs), which allow them to perform actions based on the initial command or prompt. They can also integrate with external tools and systems to complete tasks autonomously.

Use Cases for AI Agents

AI agents are already getting popular in industries like:

• Customer Service: Automating refunds and booking appointments.

• Sales and Marketing: Lead generation, email campaigns, and personalized outreach.

• Travel: Managing itineraries and booking services.

But as with any technology, there are challenges:

• Complex Implementation: Building AI agents requires more complex infrastructure in comparison to traditional chatbots.

• Ethical and Security Concerns: Due to access to external data sources, AI Agents must be designed carefully to prevent unintended actions or data breaches.

• Experimental State: We’re still learning how to best apply AI agents to different business scenarios. Therefore, the community is relatively small at the time of writing this article.

What’s Next? Multi-Agent Infrastructure

The future lies in multi-agent systems, where AI agents collaborate to handle complex processes. For example, one agent might manage customer interactions while another focuses on backend workflows—all working together seamlessly.

It’s fascinating to think how quickly the conversational AI landscape has evolved. Eight years ago, people avoided chatbots. Today, millions of people interact with ChatGPT for everything from advice to automation. The possibilities of automation are endless, but it’s important for businesses to approach this evolution thoughtfully.

Advice for Businesses

1. Start Small: Begin with an AI chatbot before scaling to AI agents. Treat this as a journey, not a destination.

2. Focus on Specific Use Cases: Think about how AI can enhance context awareness or personalization in your offering.

3. Invest in Training: Equip your teams with AI and ML skills to stay competitive. Every software engineer should learn the AI fundamentals.

4. Test and Iterate: Start with small wins to minimize risks while exploring long-term opportunities.

The evolution of chatbots shows how technology simplifies user experiences while introducing new complexities behind the scenes. It’s an exciting time to innovate—so let’s build wisely.