Building a mini-agent with tools

Section 10.7.4 : Building a mini-agent with tools

🎯 Learning objective

Conceptualize and prototype a mini AI agent by combining ChatGPT, Make, and external tools — without coding — to automate a complex task requiring reasoning and actions. You'll complete a guided end-to-end project: a competitive intelligence agent that monitors, analyzes, and distributes reports automatically.

The no-code agent: Make as orchestrator

You don't need Python or LangChain to create a functional agent. Make can serve as an agent orchestrator: the LLM "decides" (via the prompt), Make modules "execute," and the Make flow creates the "loop" between reflection and action.

Why a no-code agent?

• →Rapid prototyping: 2h vs. 2 days in code
• →Visual: you see the execution flow, not abstract code
• →Modifiable by non-developers
• →Sufficient for 90% of business use cases

What a no-code agent can do:

• →Receive a request (Slack, email, form)
• →Plan the necessary actions (via the ChatGPT prompt)
• →Execute actions (search, API, email sending, data updates)
• →Synthesize results (via the ChatGPT prompt)
• →Distribute the result (email, Slack, notification)

What a no-code agent can NOT do (yet):

• →True iterative loops (the agent can't decide to dynamically go back)
• →Dynamic tool selection (the flow is pre-defined, even if the LLM "chooses" the content)
• →Self-correction on error (error cases must be pre-planned in the flow)

The project: automated competitive intelligence agent

We'll design an agent that:

1. →Receives a question about a competitor (via Slack)
2. →Plans the necessary searches (via ChatGPT)
3. →Searches for information across multiple sources (Perplexity API + web)
4. →Analyzes and synthesizes into a structured report (via ChatGPT)
5. →Distributes the report to the team (email + Slack)

Business value: such an agent lets a strategy team ask "What is [competitor] doing right now?" and receive a complete intelligence report in 5 minutes, instead of waiting for an analyst to do the research manually in 2-3 hours.

Agent architecture

Step-by-step implementation in Make

Step 1: Configure the Slack trigger

1. →Module: Slack > Watch Messages (or Instant Message if available)
2. →Filter: messages containing @intel-agent or starting with /intel
3. →Channel: create a dedicated channel #competitive-intelligence
4. →Extraction: the user's message is stored in {{slack.text}}

Example message: @intel-agent What is Salesforce doing in terms of AI agents? Focus on Agentforce.

Step 2: ChatGPT — Intelligent planning

This first ChatGPT call serves as the planning "brain." The prompt must be highly structured so the JSON is usable:

You are an expert competitive intelligence agent. 
The user asks: "{{slack.text}}"

Analyze this intelligence request and return a structured JSON:
{
  "competitor": "[target company/product name]",
  "focus_topic": "[the specific topic to investigate]",
  "search_queries": [
    "[query 1 — recent news]",
    "[query 2 — strategic analysis]",
    "[query 3 — comparison with our industry]"
  ],
  "priority_sources": "[news, official blog, analyst reports, patents, social media]",
  "internal_data_needed": true/false,
  "report_type": "flash | standard | in-depth",
  "urgency": "high | normal | low"
}

Criteria for search queries:
- Formulate them in English (better web results)
- Include the date or "2025-2026" for recent results
- Each query should cover a different angle

Step 3: Parse the JSON

1. →Module: JSON > Parse JSON → stores the result in usable variables
2. →Now you have access to {{json.competitor}}, {{json.search_queries}}, etc.

Step 4: Multi-source research

Option A — Iterator + Perplexity API:

1. →Module: Iterator → iterates over {{json.search_queries}} (the 3 queries)
2. →For each query, module: HTTP > Make a Request
   • →URL: https://api.perplexity.ai/chat/completions
   • →Method: POST
   • →Body: {"model": "sonar-pro", "messages": [{"role": "user", "content": "{{iterator.value}}"}]}
   • →Headers: Authorization: Bearer YOUR_API_KEY
3. →Module: Aggregator → compiles the 3 results into a single text

Option B — Without Perplexity API (free alternative):

1. →Module: HTTP > Make a Request to Google Custom Search API or SerpAPI
2. →Or: Module Google Sheets > Search Rows for historical internal data

Step 5: ChatGPT — Synthesis and report

The second ChatGPT call is the "analytical core" — it transforms raw data into intelligence:

You are a competitive intelligence analyst. You write intelligence reports
for the executive committee.

Competitor analyzed: {{json.competitor}}
Focus topic: {{json.focus_topic}}

Research results:
{{aggregator.result}}

Write a {{json.report_type}} intelligence report:

## 📋 Executive Summary (3 lines max)
[Hard-hitting summary for a busy decision-maker]

## 📰 Recent News (last 7 days)
[Dated bullet points, with source in parentheses]

## 🎯 Identified Strategic Moves
[Analysis of competitor actions: new products, partnerships, hires, funding rounds]

## ⚠️ Risks and Implications for Us
[How do these moves impact our positioning? What risks?]

## 🎬 Recommended Actions
[3 concrete actions for our team, prioritized by urgency]

## 📊 Threat Score: [1-10]
[Score with justification]

Tone: analytical, factual, decision-oriented. No vague formulas.
Cite the source for EVERY factual piece of information.
If information is not confirmed by sources, flag it as "unverified."

Step 6: Report distribution

Branch 1 — Email (full report):

1. →Module: Gmail > Send an Email
2. →To: strategy-team@company.com (or a list from Google Sheets)
3. →Subject: 🔍 Intel {{json.competitor}} — {{json.focus_topic}} ({{json.urgency}})
4. →Body: the full report generated by ChatGPT

Branch 2 — Slack (summary):

1. →Module: Slack > Post a message
2. →Channel: #competitive-intelligence
3. →Message: only the Executive Summary + Threat Score + link to the full email

Step 7: Archival and tracking

1. →Module: Google Sheets > Add a Row
2. →Spreadsheet: "Competitive Intelligence History"
3. →Columns: Date, Competitor, Topic, Threat Score, Summary, Requester

This tracking enables:

• →Seeing a competitor's evolution over time
• →Identifying recurring intelligence topics
• →Measuring the agent's ROI (number of queries processed, time saved)

Testing and verification

Before deploying, test with 3 scenarios:

Test 1 (simple request): @intel-agent What are Notion's latest updates this week? → Expected: flash report, 1-2 news items, low threat score

Test 2 (complex request): @intel-agent Analyze Microsoft's AI strategy for 2026. Focus on Copilot and agents. In-depth report. → Expected: in-depth report, multiple sources, strategic analysis

Test 3 (ambiguous request): @intel-agent What's going on with Google? → Expected: the planning module should identify "Google" and formulate relevant queries despite the vague request

Validation checklist:

• → The planning JSON is valid (no parsing errors)
• → The 3 search queries are relevant and diversified
• → The report is structured according to the requested template
• → Sources are cited
• → The email sends correctly with readable formatting
• → The Slack message is concise (summary, not full report)
• → Google Sheet is updated

Limitations and future directions

What this agent does well:

• →Processes an intelligence request in 5 minutes (vs. 2-3 hours manually)
• →Structured and actionable output every time
• →Searchable history in Google Sheets
• →Triggerable by anyone on the team via Slack

Its limitations:

• →Reasoning is "one-shot": it follows the flow linearly (no true iterative loop)
• →It can't dynamically decide to add a source if results are insufficient
• →API errors (Perplexity down, rate limit) require error handling (Error handler module in Make)
• →Quality depends heavily on the synthesis prompt quality

To go further (with code):