Hash: A competitive AI marketplace where NVIDIA Nemotron agents bid, execute tasks, earn rewards, and build reputation.
Task execution dashboard showing the market status, task budget, winning bid, execution cost, and completion details.
Sealed-bid competition between Nemotron workers, followed by independent AI verification, escrow management and automated payment settlement
Transparent model telemetry tracking token usage latency, and inference costs, alongside an append-only ledger recording every market event.
Worker reputation and benchmarks showing equal success rates at 23.8× lower execution costs.

Inspiration

Choosing an AI model for a task is usually a static decision. Developers often have to guess whether an expensive, powerful model is necessary or whether a smaller model could deliver the same result.

We asked ourselves: What if AI models could compete for work instead of simply being assigned work?

That question inspired Hash — a competitive AI marketplace where models bid for tasks, execute them, and earn rewards based on independently verified results.

What it does

Hash transforms model selection into a competitive, reputation-driven marketplace powered by NVIDIA Nemotron models.

The workflow is simple:

Task Decomposition: A Manager Nemotron understands the user's goal and breaks it into executable tasks.
Sealed Bidding: Multiple Worker Nemotron models compete by submitting bids.
Deterministic Allocation: A market mechanism selects the winner based on price and reputation.
Escrow: Credits are reserved before execution.
Execution: The winning worker completes the task.
Independent Verification: A separate Verifier Nemotron evaluates the result.
Settlement: Successful work receives payment, while failures trigger deterministic penalties.
Reputation: Market events and outcomes are recorded in an append-only ledger.

Our core principle is that AI models make the judgment calls, but deterministic code controls the money. This makes financial operations transparent, predictable, and auditable.

How we built it

We built Hash using NVIDIA Nemotron models through Nebius Token Factory, combining AI inference with a deterministic marketplace infrastructure.

Our technology stack includes:

AI Models: NVIDIA Nemotron
Inference Infrastructure: Nebius Token Factory API
Backend: Python, FastAPI
Frontend: Next.js
Database: SQLite
Testing: pytest
Real-time Updates: Server-Sent Events (SSE)

We separated probabilistic AI operations from deterministic application logic. Models handle task interpretation, bidding, execution, and verification, while application code manages auctions, escrow, settlement, penalties, and accounting.

This architecture allows multiple AI models to participate in a market without giving them direct control over financial operations.

Challenges we ran into

One of our biggest challenges was coordinating multiple AI agents while maintaining reliability and consistency.

Some of the key challenges included:

Designing sealed-bid auctions that prevent workers from influencing one another's bids.
Separating AI-generated decisions from deterministic financial operations.
Handling execution failures and ensuring correct escrow and settlement behavior.
Building an independent verification mechanism rather than blindly trusting generated outputs.
Maintaining consistent reputation records and an auditable transaction history.
Making complex multi-agent interactions understandable through a real-time dashboard.

Balancing model performance, inference costs, and verification overhead was another important challenge.

Accomplishments that we're proud of

Our biggest accomplishment is demonstrating that a competitive AI marketplace can match a larger monolithic model's benchmark success rate while significantly reducing worker execution costs.

We benchmarked Hash against a monolithic 120B Nemotron model using 20 Python coding tasks with hidden pytest verification.

Our results:

Monolithic model: 20/20 tasks passed.
Hash marketplace: 20/20 tasks passed.
Hash routed all 20 tasks to a smaller 30B worker.
Worker execution was 23.8× cheaper than the 120B baseline.

The independent verifier introduces additional inference costs, which we report separately rather than hiding them.

We are also proud of implementing the complete marketplace lifecycle, from task creation and competitive bidding to verification, settlement, and reputation tracking, with an append-only audit trail.

What we learned

Building Hash taught us that multi-agent AI is much more than connecting multiple language models.

The real challenge lies in designing the coordination mechanisms, incentives, verification systems, and infrastructure that allow agents to work together reliably.

We gained practical experience with NVIDIA Nemotron, Nebius Token Factory, multi-agent orchestration, deterministic auction mechanisms, AI verification, backend architecture, and performance benchmarking.

Most importantly, we learned that the future of AI may not depend on finding one perfect model, but on building systems where the right models compete and collaborate to solve each task.

What's next for Hash

We envision Hash evolving into a more open and scalable marketplace for AI capabilities.

Our next steps include:

Supporting more AI model families and external model providers.
Introducing dynamic pricing based on workload, latency, and worker performance.
Improving reputation mechanisms using long-term reliability and verification history.
Expanding benchmark coverage beyond Python coding tasks.
Adding richer analytics for cost, performance, and model comparisons.
Exploring decentralized participation and broader developer integrations.

Our long-term vision is to make Hash a marketplace where developers can submit a goal, and capable AI agents compete transparently to deliver the best verified outcome at the right cost.

Hash makes AI model selection competitive, execution measurable, and trust verifiable.