DEV Community: Dhairya

DealClaw - Autonomous Sales Stratergist Agent

Dhairya — Sun, 07 Jun 2026 15:26:22 +0000

How We Built an Autonomous Sales AI Agent with Groq, Gemini Embeddings, and Gmail in 12 Hours

We built DealClaw in a 12-hour hackathon — a sales intelligence platform where the AI doesn't just advise, it acts. Here's the full technical breakdown.

The Problem

CRMs like Salesforce and HubSpot store everything but surface nothing. A rep closing a $200k deal has no idea that 3 months ago, a different rep handled the exact same "ROI projections are too optimistic" objection and won by sharing a Stripe case study. That institutional knowledge lives nowhere useful.

We wanted to build the intelligence layer that mines past deals and makes every rep smarter in real time.

Architecture Overview

Gmail / Slack / CRM export
        ↓
  Extraction (Groq)          raw text → structured JSON
        ↓
  Embedding (Gemini)         objections → 3072-dim vectors → Supabase pgvector
        ↓
  Agent (Groq)               deal context + retrieved memory → recommendations
        ↓
  Task execution (Groq + Gmail API)   drafts + sends emails autonomously

LLM: Groq with 3-Model Waterfall Fallback

We use Groq for all inference — latency matters a lot when the agent is running mid-conversation. The fallback chain is a single file:

const MODELS = [
  'llama-3.3-70b-versatile',  // primary — best quality
  'llama-3.1-8b-instant',     // first fallback — fast
  'gemma2-9b-it',             // last resort
];

export async function groqComplete({ messages, system, max_tokens = 1024 }) {
  let lastError;
  for (const model of MODELS) {
    try {
      const response = await client.chat.completions.create({
        model,
        messages: system ? [{ role: 'system', content: system }, ...messages] : messages,
        max_tokens,
      });
      return response.choices[0].message.content;
    } catch (err) {
      lastError = err;
    }
  }
  throw new Error(`All Groq models failed: ${lastError?.message}`);
}

If the 70B model is rate-limited or down, requests fall through silently. Callers never see the model selection logic.

Retrieval-Augmented Agent Memory

Every objection gets embedded when it's created and stored in Supabase with pgvector:

// Gemini text-embedding-004 via REST (v1beta, 3072 dims)
async function getEmbedding(text) {
  const res = await fetch(`${GEMINI_EMBED_URL}?key=${process.env.GOOGLE_AI_API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ content: { parts: [{ text }] } }),
  });
  return (await res.json()).embedding.values;
}

At query time, the agent embeds the current objection, runs cosine search, and injects the top matches into its system prompt:

SIMILAR PAST OBJECTIONS RETRIEVED:
[1] Objection: ROI projections not substantiated.
    Response: Shared Stripe/Shopify case studies showing 3.2x ROI. Added 90-day success clause.
    → Deal outcome: won | Tags: roi, SaaS, won

This is what makes the recommendations specific instead of generic. The agent literally says "in the Nexus Analytics deal, this exact objection was resolved by..."

Extraction Pipeline

Raw email or call transcript → structured JSON in one shot:

const EXTRACTION_SYSTEM_PROMPT = `You are a sales intelligence extraction engine.
Return ONLY valid JSON matching this schema:
{
  "summary": "...",
  "stakeholders": [{ "name", "role", "seniority", "sentiment", "primary_concern" }],
  "objections": [{ "text", "category", "response_used" }],
  "commitments": ["..."]
}
Category must be one of: pricing | roi | timing | competitor | champion | technical | procurement`;

We added post-parse validation — open-source models occasionally drift on enum fields:

function validateCategories(parsed) {
  parsed.objections = parsed.objections.map(obj => ({
    ...obj,
    category: VALID_CATEGORIES.includes(obj.category) ? obj.category : 'technical',
  }));
  return parsed;
}

Autonomous Task Execution

The most interesting feature. When you open a deal, the agent analyzes context and generates specific next actions:

{
  "title": "Send ROI case study to Linda Cho",
  "description": "Linda raised ROI concerns in the last call. Past won deals show 100% resolution rate when sharing auditable case studies within 48 hours.",
  "type": "email_client",
  "priority": "high",
  "payload": {
    "to_name": "Linda Cho",
    "to_role": "CFO",
    "subject": "ROI data from similar deployments",
    "context": "Address board approval concern with Stripe/Shopify examples"
  }
}

When approved, the agent drafts a personalized email via Groq, sends it via Gmail API, and logs it as an interaction — all without the rep touching a keyboard.

The Gmail send uses RFC 2822 encoding:

export async function sendEmail({ to, subject, body }) {
  const raw = [`To: ${to}`, `Subject: ${subject}`, `MIME-Version: 1.0`, '', body].join('\n');
  const encoded = Buffer.from(raw)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');
  return gmail.users.messages.send({ userId: 'me', requestBody: { raw: encoded } });
}

CRM Import — Flexible Field Mapping

Sales teams export from different CRMs with different column names. We built a normaliser that maps any column name variation to our schema:

function findField(row, candidates) {
  const keys = Object.keys(row);
  for (const candidate of candidates) {
    const match = keys.find(k => k.toLowerCase().trim() === candidate.toLowerCase());
    if (match) return row[match];
  }
  return null;
}

const company = findField(row, ['company', 'account', 'account name', 'organization']);
const stage   = findField(row, ['lead status', 'stage', 'deal stage', 'pipeline stage']);

Supports CSV, Excel (.xlsx), JSON, XML, and PDF. A HubSpot export and a Salesforce export both work without configuration.

What We'd Do Differently

Streaming responses — Groq supports streaming but we used blocking calls. For the agent chat, streaming would make the UX feel much more alive.
Smarter deduplication — we deduplicate Gmail by message ID, but if the same email arrives via a forwarded thread, it gets re-imported. Content hashing would be more robust.
Async task execution — currently tasks execute synchronously on the server. For long-running tasks (multiple emails), a queue (BullMQ or Supabase edge functions) would be cleaner.

Stack

Layer	Tech
LLM	Groq (llama-3.3-70b, fallback chain)
Embeddings	Gemini text-embedding-004 (3072 dims)
Vector search	Supabase pgvector
Backend	Node.js + Express
Frontend	React 19 + Vite + Tailwind
Email	Gmail API (OAuth2)
Hosting	Render

GitHub: github.com/Dhairya1890/deals_agent

Happy to answer questions about any part of the architecture.

Guidewire DevTrails 2026 Hackathon Experience So Far...

Dhairya — Sat, 28 Mar 2026 18:16:38 +0000

Building Trigr: 45 Days, One Market Crash, and a lot of DC Coins

A dev blog by Team AlooParatha — Guidewire DEVTrails 2025/2026

Day 0: Wait, We Are a Startup Now?

Most hackathons start with a Discord announcement, a problem statement PDF,
and 24 hours of caffeine. DEVTrails started with something different: a
briefing that made us feel less like students and more like three people who
just signed a lease on an office they cannot afford.

The rules were simple. You are not a team. You are a startup. You have DC
Coins, the in-universe currency of the hackathon. You spend coins to operate,
to seek guidance, to protect yourself from events. You earn them by supporting
other teams. And every week, something happens that you did not plan for.

There are three of us on Team AlooParatha. We spent the first day arguing about
what we were actually going to build.

The problem space was InsurTech. And once we started looking at it, we could
not unsee it.

The Problem We Could Not Ignore

India has over 12 million platform-based delivery workers. Swiggy. Zomato.
Blinkit. Zepto. These are people working 10-hour days on two-wheelers, earning
somewhere around Rs 4,000 to Rs 5,000 a week.

Then the monsoon arrives.

Three days of heavy rain in Mumbai means three days of no deliveries. No work.
No pay. No recourse. No claim to file because there is no insurance to begin
with. There is no product in India today built specifically for this gap.

We called our product Trigr.

The idea: workers pay a small weekly premium. When a verified external
disruption hits their zone, a flood, severe AQI, a curfew, a city bandh,
Trigr detects it automatically and sends a payout directly to their UPI.
No paperwork. No claim filing. No waiting.

We had our problem. We had our solution. Now we had to build it in 45 days
while the hackathon tried to break us.

Building It

We will not go into the full architecture here, that is for another day.

What we will say is that Trigr has multiple moving parts working together:
an engine that handles income verification and weekly pricing, a system that
monitors external disruptions and fires automated triggers, an intelligence
layer that handles risk and fraud, and dashboards built for three different
types of users.

Every design decision came back to one question: what does a delivery worker
in Dharavi actually need when it is raining and he cannot work? The answer
is not a claims form. It is money in his UPI before the day is over.

Phase 1 Submissions. Then the Market Crashed.

We were three days from Phase 1 submission. The README was almost done.
The demo was almost working. We were, in the language of startup founders
everywhere, almost there.

Then this arrived in our feed:

"500 delivery partners. Fake GPS. Real payouts. A coordinated fraud ring
just drained a platform's liquidity pool and yours is next."

The Market Crash event. A challenge injected mid-hackathon by the Guidewire
team. We had 24 hours to respond.

We stopped. We held our Phase 1 plans. We got on a call and started from
scratch on the problem.

We will not detail our solution here, but the core challenge was this: how
do you protect genuine workers from being caught in the crossfire while
making sure fraudsters do not get through? Getting that balance right was
the hardest design problem we faced in the entire hackathon.

We updated the README. We submitted Phase 1.

What DEVTrails Actually Is

Here is the thing about this hackathon that no description quite captures:
it does not let you coast.

Normal hackathons have a problem statement, a deadline, and a demo. DEVTrails
has DC Coins that simulate startup funding. You spend coins to keep operating,
to get mentorship, to protect yourself from market events. You earn them by
supporting other teams in the ecosystem.

The Market Crash was not the only curveball. Quizzes dropped mid-phase.
Challenges appeared that forced us to rethink assumptions baked into our
product weeks earlier. Every time we thought we had things locked, something
arrived that made us go back to first principles.

This is what building a real product actually feels like. The requirements
do not freeze at kick-off. The market does not wait for you to finish your
README.

We are a 3-person team. We are a startup. We have completed Phase 1.

What Is Next

The grind continues. More updates from the Trigr journey coming soon.

And if you are a delivery worker in anywhere in India wondering when the next monsoon
payout is coming, we are working on it.

Team AlooParatha. Building Trigr at Guidewire DEVTrails 2025/2026.

Massive shoutout to the Guidewire team for building something that actually
teaches you what startup culture feels like, not just what it looks like
on a slide.

New Claude Model

Dhairya — Thu, 19 Mar 2026 04:09:34 +0000

The AI space doesn’t slow down—and Anthropic just dropped a new Claude model that’s worth paying attention to. But instead of hype, let’s break down what actually matters for developers, builders, and students trying to use it in real projects.

🚀 What’s New?

The latest Claude model focuses on three major upgrades:

Better Reasoning (Finally Useful for Real Tasks)

Claude has significantly improved its ability to:

Follow multi-step logic

Handle complex instructions

Stay consistent across long conversations

This isn’t just benchmark improvement—it actually reduces the number of times you need to “fix” the model mid-task.

Larger Context Window (Game-Changer)

One of Claude’s strongest advantages continues to grow:

Can process very large inputs (like full codebases, PDFs, or docs)

Maintains context better over long interactions

👉 This is huge if you're building:

AI note summarizers

Repo analyzers (like your README generator idea 👀)

Document-based Q&A tools

More Reliable Outputs

Compared to earlier versions:

Less hallucination (still not zero)

More structured responses

Better formatting for code and explanations

This means fewer guardrails needed in your app.

🧠 Where Claude Actually Shines

From a developer perspective, Claude is especially strong in:

• Code Understanding (Not Just Generation)

It’s really good at:

Reading large codebases

Explaining logic clearly

Refactoring messy code

👉 If you’ve ever struggled to understand solutions (like in DSA), Claude can actually teach, not just output answers.

• Long-Form Content Tasks

Claude performs very well in:

Writing documentation

Summarizing research papers

Generating structured notes

This aligns perfectly with:

AI notes-making tools

Study assistants

Knowledge extraction systems

• Safety + Control

Anthropic focuses heavily on alignment:

More predictable outputs

Less random behavior

Better adherence to instructions

This matters when you're building user-facing apps.

⚠️ Where It’s Still Not Perfect

Let’s be real:

Still hallucinates in edge cases

Can be overly verbose sometimes

Not always the fastest model

👉 So you still need:

Validation layers

Prompt engineering

Possibly hybrid systems (Claude + other models)

🛠️ Practical Use Cases You Can Build

If you're a student or dev, here are high-impact ideas:

Repo → README Generator

Feed a GitHub repo → generate clean documentation
(You literally asked about this recently—Claude is perfect here.)

AI Study Assistant

Upload PDFs

Get summaries + questions

Generate revision notes

Code Debugging Assistant

Paste buggy code

Get step-by-step reasoning

Understand why something failed

Hackathon Projects

Claude is especially useful for:

Rapid prototyping

Explaining complex logic to judges

Generating structured outputs

💡 My Take (No Hype)

Claude isn’t just “another LLM.”

It’s becoming:

A thinking + reading model, not just a “text generator.”

If you’re building anything involving:

Large inputs

Understanding over generation

Clean explanations

…it’s honestly one of the best tools right now.

🔚 Final Thoughts

If you're serious about:

Cracking internships

Building meaningful AI projects

Actually understanding code instead of copying it

Then learning how to use models like Claude properly is a skill in itself.

Not prompt engineering hacks.

But:

Structuring problems

Feeding the right context

Validating outputs

If you want, I can help you:

Build a project using Claude

Compare Claude vs GPT for your use cases

Design something hackathon-ready

Just tell me 👍