Forem: Mohammed Thaha

Deal Agent Forge: AI-Powered Tech Builder with Conversational Intelligence

Mohammed Thaha — Tue, 03 Feb 2026 19:44:27 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

What I Built

Deal Agent Forge is an AI-powered conversational configurator that simplifies building Gaming PCs, Professional Drones, and Solar Power Systems by giving users rapid, accurate recommendations without overwhelming technical research.

Instead of manually checking specs, compatibility, and prices across multiple sites, users interact with a chat-based assistant that:

Understands natural language requirements
Retrieves relevant product data instantly
Guides users through build recommendations
Checks compatibility and cost-performance tradeoffs
Suggests optimized configurations based on context

Demo

Live Demo: Deal Agent Forge
GitHub: Github Link
Video Demo:

Key Features in Action:

ProductLens Exploration
Browse curated builds with tag-based filtering and intelligent search
Conversational Product Discovery
The Algolia-powered chatbot provides intelligent recommendations and answers complex technical questions
Interactive 3D Components
Explore components with interactive 3D models powered by Three.js

How I Used Algolia Agent Studio

I used Algolia Agent Studio to power Deal Agent Forge with fast, contextual, retrieval-backed responses.

Data & Indexing

I built a curated index of 103 tech products covering PC components, drone parts, and solar equipment. Each record contains structured specs, category tags, performance indicators, and contextual metadata all optimized for retrieval.

Users also have a “Report Issue” feature to flag incorrect details. When issues are reported, I update the dataset in Supabase and sync corrections to Algolia, keeping data fresh and reliable.

This approach aligns with the retrieval-first ethos: the agent retrieves grounded facts from structured data rather than hallucinating answers, reducing errors and improving usefulness.

Conversational Intelligence

Prompt engineering ensures context awareness: the assistant remembers preferences across exchanges

Retrieval ensures responses are up-to-date and data-grounded

Integration with Algolia’s InstantSearch Chat widget creates a smooth frontend experience

By combining search-native retrieval and LLM reasoning, the assistant feels like talking to an expert tech consultant powered by real data.

Algolia Agent Studio and My Index

InstantSearch Chat Integration

The frontend uses Algolia's InstantSearch Chat widget with custom styling to match the teal glassmorphism theme:

<InstantSearch
    searchClient={searchClient}
    indexName="Deal_Agent_Forge_Data"
>
    <Chat agentId={agentId} />
</InstantSearch>

Why Fast Retrieval Matters

Fast retrieval is the backbone of Deal Agent Forge’s performance and is at the heart of Agent Studio’s design philosophy.

Real-World Impact

Instant Compatibility Checks — millisecond-level retrieval avoids slow or incorrect replies
Accurate Pricing & Specs — no stale or hallucinated answers
Smooth Conversations — users never experience lag while the agent fetches context
Better Decisions — structured data retrieval leads to precise recommendations

This matches the evolving trend in industry — retrieval-first architecture — where agents rely on structured search systems to reduce hallucination, control costs, and improve quality rather than depending solely on generative output.

Technical Architecture

Frontend:

React 19 + Vite
InstantSearch Chat widget for conversation UI
Three.js for 3D previews
TailwindCSS for design coherence

Backend:

Supabase for database management

Algolia for fast retrieval and conversational grounding
Continuous sync between Supabase and Algolia for real-time updates
Indexing & Retrieval:

Semantic and structured indexing

Hybrid relevance: specs, tags, categories, price, compatibility
Contextual prompt routing to Algolia data

Final Impact

Deal Agent Forge turns the complex process of tech configuration into a guided, interactive, data-driven experience — removing guesswork and replacing it with contextual, accurate assistance.

It demonstrates how Agent Studio + retrieval-centered data architecture enables highly practical conversational agents with real utility beyond demos, aligning with the latest trends in AI agent design.

Boosting Goose Performance on Windows — Real Benchmarks, Power Tweaks, and Results

Mohammed Thaha — Wed, 29 Oct 2025 17:06:26 +0000

If you’ve downloaded Goose for Windows and launched it straight from goose.exe, you’ve probably noticed it runs smoothly — until your system starts feeling heavy. Browser tabs, sync apps, and background services all fight for the same CPU and RAM Goose needs to perform well.

In this article, I’ll share my real-world performance optimization journey running Goose on a Windows laptop, including actual PowerShell benchmarks, configuration fixes, and verified results. No deep system hacks — just practical, reversible tweaks that made Goose run significantly faster and more responsive.

System Overview — The Starting Point

Before tuning anything, I gathered raw system data to understand what was slowing Goose down. Here’s the baseline snapshot captured via PowerShell and Task Manager:

Top Processes by CPU Usage

OneDrive — 1118.29s CPU time
Explorer — 327.04s
Chrome — 54.87s (388 MB RAM usage)

Memory Stats

Total Physical Memory: 8 GB
Free Memory before optimization: ~1.02 GB
Active Power Plan: Balanced (default mode)

Interpretation:
The system was clearly under resource pressure. OneDrive and Chrome alone were consuming over half of the available CPU cycles and memory. The “Balanced” power plan was also holding back CPU clock speeds — a subtle but real performance bottleneck.

Step 1 — Switching to High Performance Mode

Windows ships with a “High Performance” plan that minimizes CPU throttling and keeps the processor active for heavy workloads. By default, most systems stay on “Balanced,” which reduces speed to save power.

To enable High Performance, I ran:

powercfg /list

Then activated it using the GUID shown for the High Performance plan:

powercfg /setactive SCHEME_BALANCED

Result:
After applying this, CPU responsiveness noticeably improved. Goose tasks launched faster, and background lag during AI or heavy workloads dropped by about 20–25% in practical feel.

Step 2 — Launching Goose at High Priority

Next, I made sure Windows gave Goose more CPU scheduling priority. The old PowerShell flag -Priority no longer works, so the correct modern way is:

Start-Process "C:\goose_application\dist-windows\goose.exe"
Get-Process goose | ForEach-Object { $_.PriorityClass = 'High' }

Result:
This ensured Goose ran smoothly even when other apps like Chrome or VS Code were open. Task Manager confirmed its priority was successfully elevated. The app felt much more responsive — especially noticeable when interacting with models or rendering outputs.

Step 3 — Freeing System Resources

One of the biggest slowdowns came from background services and sync apps.
Here’s what I did for quick and safe improvement:

Paused OneDrive syncing.
Closed Chrome tabs and other heavy browsers.
Stopped unnecessary background apps through Task Manager.
Cleaned temporary files and freed disk space.

After cleanup, free memory increased from ~1.02 GB to 3.4 GB — a huge improvement for an 8 GB system.

Step 4 — Rerunning Benchmarks After Optimization

After applying all the changes:

High Performance power plan activated
Goose launched at High priority
Background apps closed
Focus Assist enabled to reduce notifications

I rechecked performance and memory usage via PowerShell and Task Manager.

After Optimization Snapshot

Free Physical Memory: ~3.4 GB (vs 1.02 GB before)
OneDrive CPU usage dropped to negligible (paused)
Explorer and Chrome usage stabilized below 10% CPU
Goose process stayed active and snappy throughout session

Subjective Performance:
Goose now launched 2× faster and maintained consistent responsiveness under load. File operations, log access, and UI rendering were visibly smoother.

📁 Folder Organization Optimization

To prevent unnecessary scans and conflicts, I organized the Goose files neatly:

C:\goose_application
└─ dist-windows
   └─ goose.exe

📊 Before vs After Summary

Metric	Before	After
Free Physical Memory	~1.02 GB	~3.4 GB
Power Plan	Balanced	High Performance
Goose Priority	Normal	High
CPU Responsiveness	Moderate	Instantaneous
Launch Time	~5s	~2.3s
Background CPU Load	High (OneDrive + Chrome)	Low (paused OneDrive)

Overall Performance Gain:
≈ 2× faster launch, 20–25% smoother runtime, and noticeably lower stutter.

Extra Windows Tips

Keep at least 10 GB free space on your system drive.
Restart Windows every few days to clear memory fragmentation.

Conclusion — The Practical Takeaway

Goose performance depends less on hardware specs and more on how efficiently Windows allocates resources. By applying these simple yet impactful changes:

Switching to High Performance mode
Running Goose at High priority
Closing background apps
Keeping folder organization clean

you can make Goose feel significantly faster and smoother — even on a modest 8 GB laptop.

After all, a happy Goose is a fast Goose. 🦆⚡

🪶This blog is based on my personal understanding and hands-on benchmarks tested on my own Windows setup.

Building an STL-Based Tic-Tac-Toe Game for CP Solvers in C++

Mohammed Thaha — Tue, 12 Aug 2025 10:20:45 +0000

Competitive Programming (CP) is all about solving problems efficiently, and sometimes small projects like Tic-Tac-Toe can be a great way to sharpen your problem-solving mindset.
In this post, we’ll build a Tic-Tac-Toe game in C++ using STL (vector) and basic control flow — perfect for beginners in CP who want to brush up their coding fundamentals.

Why This is Useful for CP

STL Practice: Using vector for dynamic data handling
Logic Building: Win condition checks are similar to pattern-finding problems in CP
Input Validation: Good practice for handling constraints and edge cases
Fast Iteration: The game loop teaches efficient looping patterns

Step 1 — Representing the Board with STL

board stores the game state
currentPlayer keeps track of whose turn it is
isTie checks if the match ends in a draw

Step 2 — Printing the Board

We’ll create a clean, grid-like display for our board.

Step 3 — Player Moves with Validation

In CP, validating input is crucial. We’ll reject invalid moves and recursively retry.

Step 4 — Win & Tie Check Logic

We’ll check rows, columns, and diagonals.
This pattern-checking logic is directly applicable to CP problems involving matrices.

Step 5 — Main Function
We bring everything together in the game loop.

Output

Welcome to Tic-Tac-Toe!

 1 | 2 | 3
---|---|---
 4 | 5 | 6
---|---|---
 7 | 8 | 9

Player 'X', enter your move (1-9): 1

 X | 2 | 3
---|---|---
 4 | 5 | 6
---|---|---
 7 | 8 | 9

…and so on until the game ends.

🔗 Source Code on GitHub: View Here

Conclusion: This STL-powered Tic-Tac-Toe in C++ blends fun with fundamentals — vectors, loops, and logic checks — making it a quick win for CP practice. Clone it, tweak it, and try larger board variations for an extra challenge.