AutoBid Arena AI — In-Depth Project Explanation
- What the Project Is AutoBid Arena AI is a continuous-action, memory-augmented, multi-agent web intelligence agent. It is not just a chatbot. A normal chatbot works like this: User asks question → AI answers → process ends
The project works like this: User gives his goal : agent searches live web extracts evidence validates sources compares with memory ranks opportunities decides an action publishes alert logs action repeats monitoring
So the core idea is to build an AI agent that acts like a real autonomous analyst and not just a text generator.
- Main Use Case The current demo use case is: “Find AI healthcare operations command-center startup opportunities for hospital workflow, patient flow, and staff scheduling”
The agent searches real-time web data and finds opportunities around: hospital operations command centers patient-flow optimization staff scheduling automation bed management workflow automation healthcare operational intelligence AI-powered hospital administration Then it decides whether the opportunity should be: ALERT_NOW WATCHLIST RESEARCH_MORE IGNORE
This action decision is what makes it agentic.
- High-Level Architecture The architecture is: User Goal ↓ Planner Agent ↓ Search Agent ↓ Evidence Collector ↓ Evidence Validator ↓ Memory Agent ↓ Opportunity Extraction Agent ↓ Game-Theory Strategy Agent ↓ Risk Analyst Agent ↓ Action Policy Agent ↓ Discord Publisher Agent ↓ Action Logger ↓ Memory Update ↓ Continuous Monitoring Loop
In simple terms: Search → Reason → Remember → Decide → Act → Log → Repeat
Architecture Diagram ┌────────────────────────────┐ │ User Goal │ │ "Find healthcare AI ops" │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Planner Agent │ │ Creates search strategies │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Search Layer │ │ Tavily + DuckDuckGo │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Evidence Collector │ │ title, URL, snippet, query │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Evidence Validator │ │ Removes weak/fake sources │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Memory Agent │ │ Compares with past runs │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Opportunity Extraction │ │ Finds startup opportunities │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Game-Theory Strategy Agent │ │ Scores and ranks strategies │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Action Policy Agent │ │ ALERT / WATCH / RESEARCH │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Discord Publisher │ │ Posts autonomous alert │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Action Logger │ │ Saves action history │ └──────────────┬─────────────┘ ↓ ┌────────────────────────────┐ │ Continuous Monitoring Loop │ │ Repeats the process │ └────────────────────────────┘
Frontend Layer — Streamlit UI The project uses Streamlit as the frontend. The Streamlit dashboard gives controls for: Search Provider Results per search query Auto-refine output quality Enable Memory Show Memory Allow autonomous Discord actions Enable Continuous Monitoring Mode Monitoring cycles Seconds between cycles
The Streamlit UI also shows output tabs: Search Queries Web Evidence Memory Action Decision Final Output Evaluation Action Log
- Search Layer The search layer uses: Tavily Search API DuckDuckGo fallback search Demo fallback evidence
Why Tavily? Tavily is useful because it returns structured web results: title URL content snippet
This is better than plain scraping because it is cleaner and easier to use for evidence-grounded reasoning. Search Flow The agent takes the user goal and creates multiple web queries. Example: AI healthcare operations command center hospital operations AI staff scheduling healthcare workflow automation AI patient flow hospital bed management healthcare operations AI startup market pain points
Then it searches the web for each query.
- Evidence Collection Layer Each search result is converted into a structured evidence object. Example: { "title": "Building the new virtual hospital command center", "url": "https://leantaas.com/...", "snippet": "AI-powered technology analyzes and distributes crucial information...", "query": "hospital operations AI patient flow command center", "source_engine": "Tavily" }
This evidence is then passed to the LLM. This is important because the model does not reason blindly. It reasons from retrieved evidence.
- Evidence Validator Agent This agent ensures that the output remains grounded. It follows rules such as: Use only provided evidence. Use exact source URLs. Do not invent statistics. Do not write fake sources. If evidence is weak, say evidence is limited.
This was important because earlier versions produced weak citations like: Source URL: 1
The improved version forces real URLs.
- Memory Layer The project has persistent local memory stored in: agent_memory.json
The memory stores: timestamp goal evidence URLs average score action taken summary
Why Memory Matters Without memory, the agent behaves like a one-time chatbot. With memory, it can say: This opportunity is new. This source appeared before. This evidence is stronger than last time. This opportunity is repeated. This trend is continuing.
This makes the system a monitoring intelligence agent.
- Memory-Aware Reasoning When the agent runs again, it loads previous memory and compares current findings with past runs. Example: New Opportunity: Cleveland Clinic staffing AI article was not present in earlier memory.
Repeated Opportunity: LeanTaaS hospital command center appeared in previous scans.
Stronger Opportunity: Hospital command center evidence is stronger because multiple sources now support it.
This gives the agent longitudinal awareness.
Multi-Agent Reasoning Layer The system uses a compressed multi-agent architecture. This means multiple agent roles are simulated inside one Groq LLM call for speed. The agents include: Planner Agent Understands the goal and frames the search strategy. Market Research Agent Analyzes web evidence and identifies market signals. Opportunity Extraction Agent Find specific startup opportunities. Evidence Validator Agent Checks grounding and source quality. Memory Agent Compares current evidence with previous runs. Game-Theory Strategy Agent Ranks opportunities using a payoff function. Risk Analyst Agent Identifies risks and uncertainties. QA Checker Agent Checks hallucinations and output quality. Action Policy Agent Decides what the system should do next. Final Demo Writer Agent Produces a polished output for a hackathon presentation.
Game-Theory Strategy Layer This is one of the strongest parts of the project. The system treats every opportunity as a possible strategy. For example: Strategy 1: AI hospital command center Strategy 2: AI patient-flow optimizer Strategy 3: AI staff-scheduling assistant Strategy 4: AI workflow automation system
Each strategy is scored. The scoring criteria are: Market Pain Feasibility Evidence Strength Novelty Demo Fit Competitive Advantage Autonomy Fit
The payoff formula is: Payoff = 0.20 × Market Pain
- 0.15 × Feasibility
- 0.20 × Evidence Strength
- 0.15 × Novelty
- 0.15 × Demo Fit
- 0.10 × Competitive Advantage
- 0.05 × Autonomy Fit
The strategy with the highest payoff becomes the recommended opportunity.
- Why Game Theory Helps Game theory gives the system strategic decision-making ability. Instead of saying: Here are some ideas.
the agent says: These opportunities compete as strategies. This one has the highest payoff. This one should be prioritized.
That makes the output more explainable and business-oriented.
- Action Policy Layer This is where the agent becomes more than a summarizer. The agent chooses one action: ALERT_NOW WATCHLIST RESEARCH_MORE IGNORE
ALERT_NOW Means: Evidence is strong. Opportunity is relevant. Action should be taken immediately.
WATCHLIST Means: Opportunity is promising. Continue monitoring. Do not escalate fully yet.
RESEARCH_MORE Means: Evidence exists but is incomplete. More investigation is needed.
IGNORE Means: Opportunity is weak, redundant, or not useful. This action policy is central to the project.
- Discord Publisher Layer If enabled, the agent posts the selected action to Discord. Example message: AutoBid Arena AI Autonomous Action
Goal: Find AI healthcare operations command-center startup opportunities
Action: ALERT_NOW
Top Evidence URLs: ...
Agent Summary: ...
This message was posted automatically by the agent after monitoring, scoring, memory comparison, and action decision.
This proves the system can act externally.
- Action Log Layer Every action is saved in: agent_action_log.json
The log contains: { "timestamp": "2026-05-23 13:05:26", "goal": "Find AI healthcare operations command-center startup opportunities", "action": "ALERT_NOW", "reason": "Parsed from Action Decision section.", "discord_status": "Posted to Discord. Status code: 200", "urls": [...] }
This is important because it gives an audit trail. Judges can see that the agent did something, not just generated text.
- Continuous Monitoring Loop The agent can run multiple cycles. Example: Cycle 1: Search → Reason → ALERT_NOW → Publish → Log
Cycle 2: Search → Compare memory → WATCHLIST → Publish → Log
Cycle 3: Search → Compare memory → RESEARCH_MORE → Publish → Log
This is the continuous-action part of the project. It shows the agent can work repeatedly without manual intervention.
- Self-Evaluation Layer The agent evaluates its own performance. It scores: Relevance Evidence Grounding Completeness Actionability Novelty Demo Quality Autonomy Strategic Reasoning Memory Use Web Action
This helps demonstrate quality and reliability.
- Data Flow in the System The full data flow is:
- User enters goal
- Planner creates search queries
- Tavily retrieves web results
- Results are converted into evidence
- Memory is loaded from JSON
- Evidence + memory are sent to Groq
- Groq performs multi-agent reasoning
- Output includes opportunities, ranking, and action
- Action is parsed from output
- If enabled, Discord alert is sent
- Memory is updated
- Action log is updated
- UI displays all outputs
Loop repeats if continuous mode is enabled
Why This Fits the Hackathon Theme The hackathon asks: How well does the agent act on the web using real-time data without manual intervention? The project fits strongly because it: uses real-time web search validates evidence remembers previous runs makes strategic decisions publishes external alerts logs autonomous actions runs repeated monitoring cycles
This is the kind of behavior expected from an agentic web system.
Difference from a Chatbot Chatbot AutoBid Arena AI Answers once Continuously monitors No memory Persistent memory No action Publishes alerts No strategy Game-theory ranking No audit trail Action logs No autonomy Autonomous action policy No monitoring Multi-cycle execution
The project combines: LLM reasoning real-time search structured evidence memory multi-agent prompting game-theory scoring continuous loops external actions logging evaluation
That is a strong technical stack for a hackathon.
Current limitations: Memory is JSON-based, not vector-based. Discord is the main action channel. Browser automation is not yet included. Search depends on Tavily/DuckDuckGo result quality. The agents are prompt-simulated rather than separate deployed services.
Future Improvements Future versions will add: vector memory browser automation Slack/Jira/Notion integrations scheduled background jobs reinforcement learning-based action policy multi-user workflows dashboard analytics agent-to-agent negotiation real API task execution
Final Project Summary AutoBid Arena AI is a continuous-action autonomous web intelligence agent. It combines: real-time web search multi-agent reasoning persistent memory game-theoretic ranking autonomous action decisions Discord publishing action logging continuous monitoring self-evaluation
The system demonstrates how AI agents can move from passive chatbots into autonomous systems that observe, reason, act, remember, and repeat.
Log in or sign up for Devpost to join the conversation.