AgentBid

The bidding path must remain deterministic and extremely small; AI belongs beside it as an observable operations plane.

An open architecture for real-time bidding operations, combining a high-throughput data plane with explainable AI assistance.

At a glance

• Status: Open-source architecture · In design
• Architecture focus: Platforms
• Primary outcome: Designed for sub-5ms execution
• Stack: Rust, Kafka / Redpanda, ClickHouse, Next.js, Privacy signals

The challenge

Advertising decisions demand extreme speed while operations teams still need transparency, privacy controls, and usable explanations.

The architecture decision

Keep the deterministic bidding path small and native; place analytics and agentic operations on an asynchronous control plane.

System architecture

Responsibility moves through explicit boundaries. Each layer has one primary job; policy, health, and trace signals span the system.

Open the standalone architecture and workflow diagrams.

Architecture layers

1. Rust bidder — Parse, validate, score, and respond on the latency-critical auction path.
2. Event stream — Publish auction, decision, privacy, win, and outcome events asynchronously.
3. ClickHouse — Aggregate high-volume event data for attribution, anomalies, and operational analysis.
4. Privacy policy — Decode TCF/GPP signals and apply identity, consent, retention, and regional rules.
5. Agent operations — Investigate anomalies, explain changes, and recommend bounded operational actions.
6. Reporting console — Expose performance, spend, quality, privacy, and system health in real time.

How the system works

1. Decide — A compact native service handles the auction under a strict latency and allocation budget.
2. Stream — The response is not blocked by analytics; structured events flow to Kafka or Redpanda.
3. Aggregate — ClickHouse materializes operational, attribution, and fraud-oriented views.
4. Assist — Agents inspect evidence and propose actions through policy-controlled tools outside the bidding path.

Architecture decisions and trade-offs

ADR-01: No LLM on the hot path

Auction execution remains deterministic, native, benchmarkable, and independently deployable.

Trade-off: The agent cannot improvise per bid, which preserves latency, cost, and reproducibility.

ADR-02: Events are the product memory

A shared event vocabulary connects bidding, billing, privacy, analytics, and incident response.

Trade-off: Schema governance becomes essential, but teams stop reconciling incompatible operational truths.

ADR-03: Privacy is a decision input

Consent and regional policy are resolved before identity or targeting features are used.

Trade-off: Fewer signals may be available for some auctions, but compliance is enforced by architecture instead of convention.

Production qualities

• Performance: Preallocated structures, bounded work, native execution, and no synchronous analytics dependencies.
• Privacy: TCF/GPP decoding, consent-aware identity, regional policy, and retention controls.
• Auditability: Decision features, policy state, model/config versions, and outcomes share traceable event IDs.
• Operations: Agents use read-first tools, explicit budgets, approvals, and reversible actions.

Outcomes

• A sub-5ms design target for edge execution
• Independent scaling of bidding and analytics
• Transparent multi-touch attribution patterns
• AI assistance without risking auction determinism

Technology stack

• Rust
• Kafka / Redpanda
• ClickHouse
• Next.js
• Privacy signals

Related writing

• Production agent systems need bounds, not bigger prompts
• Scale data pathways before code complexity
• Privacy is a decision input, not a downstream filter