Deployed demo
IntelliBid
Auction platform with a conversational bidding agent
- My role
- Sole engineer — agent design, real-time bidding, frontend
- Timeline
- 2026
- Team
- Solo
Outcome
- Agent
- bids autonomously within a user-set ceiling
- Explained
- every automated action carries its rationale
- Live
- WebSocket bidding with server-ordered writes
- 3D
- interactive lot inspection before bidding
What it looks like
Context
Auction interfaces assume a user who is watching. Anyone not watching at the moment a lot closes simply loses it, which is why sniping tools exist at all. The project began from a straightforward question: if an agent can be told an intent and a ceiling, why should a person have to sit at the screen?
The problem
- An agent that spends a user's money is a materially different proposition from a chatbot. Its authority has to be bounded before it acts, not apologised for afterwards.
- An agent whose reasoning is opaque is unusable in this setting. A user who cannot see why a bid was placed cannot decide whether to keep delegating.
- Auction state is contested by construction: several bidders and their agents act on the same lot within the same second, and the ordering has to be authoritative.
- Natural-language intent is ambiguous, while a bid is exact. Something has to convert one into the other without quietly inventing the parts the user did not specify.
How I approached it
Give the agent a ceiling before giving it authority
Delegation always begins with an explicit maximum. The agent operates strictly inside that envelope and is structurally incapable of exceeding it, which makes the worst case something the user chose in advance rather than something the model decided.
Within that envelope the agent bids incrementally rather than immediately committing the ceiling, so a user's maximum is a limit rather than a starting price.
Require the agent to narrate every action
Each bid the agent places carries a plain-language explanation of why it was placed. The intent is not decoration: an agent that must justify an action is far easier to evaluate, and a user who disagrees with the reasoning can withdraw delegation before the next round.
Treating explanation as a product requirement rather than a debugging aid was the decision that made the feature trustworthy enough to use.
Constrain the language interface to a resolved query
Free-text intent is resolved into an explicit, structured query — category, ceiling, constraints — which the user can see and correct before anything is committed. Ambiguity is surfaced rather than silently resolved by the model.
The same structured representation drives both search and the agent's subsequent behaviour, so what the user reviewed is exactly what executes.
Serve the bid path over WebSockets
Bids, outbid notifications and closing timers are pushed rather than polled, so a competing bid reaches every participant — human or agent — as one ordered stream of events.
The server sequences bids authoritatively. Contested lots resolve against server ordering rather than client clocks, which is the only defensible answer when money is attached to the outcome.
Architecture
Intent
- Natural-language request
- Ceiling & constraints
Agent (Gemini)
- Query resolver
- Bounded bid policy
- Action explainer
Bid engine
- Server-ordered bid sequencing
- Lot state & closing timers
Transport
- WebSocket channel per lot
Participants
- Human bidders
- Delegated agents
- Sellers
Cross-cutting
- Delegation records — every automated action stored with its rationale
- Frontend
- React · interactive 3D lot previews · live bid stream
- Realtime
- WebSocket channels per lot — bids, outbid alerts, closing timers
- Agent
- BidMind — Google Gemini, bounded by a user-set ceiling, emitting an explanation per action
- Backend
- Node.js REST API · authoritative server-side bid sequencing
- Data
- MongoDB — lots, bids, users, agent delegation records
- Roles
- Bidder · pro bidder (agent access) · seller
Trade-offs I chose
A hard user-set ceiling as a precondition of delegation
WhyThe failure mode of an autonomous agent with a wallet is unbounded. Making the bound a precondition rather than a guardrail means the worst outcome is one the user authored themselves.
Mandatory per-action explanations
WhyTrust in an agent is not established by accuracy alone. If a user cannot audit a decision, they will stop delegating regardless of whether the agent was right.
Resolving natural language into a reviewable structured query
WhyInterpreting intent silently is where conversational interfaces lose people. Showing the resolved query converts a guess into something the user can confirm or correct.
Server-authoritative bid ordering
WhyClient timestamps are unreliable and, in an auction, adversarial. The only sequencing anyone will accept is the one the server produces.
What I took away
- The engineering difficulty in an agent product is not the model. It is deciding precisely what authority the agent holds and making that boundary structural rather than advisory.
- Requiring the agent to explain itself improved the system twice over: users could evaluate it, and so could I — most of the behaviours I corrected were ones the explanations exposed.
- Anything involving money converges on the same conclusion as ChefOS did: the server orders events, and the client renders the result.
Stack
- React
- Node.js
- WebSockets
- LLM agent
- 3D previews
- MongoDB