Builders & Brews Amsterdam: Nebius x NVIDIA AI Hackathon

On Friday 25 September 2026 I went to Builders & Brews: Hack Edition, run by AAIF Community Amsterdam. It was the Amsterdam stop of the Nebius x NVIDIA Global AI Hackathon tour. The agenda slide carried the Nebius and Tavily logos and ran from doors at 4:00 pm, through talks from 5:00 pm, to “Build, networking… Present ideas for feedback” until 10:00 pm. I was there for the opening and the first talks, from the hackathon briefing to Kilo Code.

The short version, if you’re thinking of entering: submissions close on 30 October 2026 at 10:00 am Pacific Time. Every project has to run on Nebius Token Factory or Nebius AI Cloud and use at least one NVIDIA open source model. The rules, tracks and prizes are below, as published on the official Devpost page, followed by the recipe I’d use to get an agent submitted in the four weeks left.

AAIF Community Amsterdam: a new local chapter

The opening slides were branded Agentic AI Foundation. The Agentic AI Foundation (AAIF) is the Linux Foundation’s home for open agentic AI standards. The Linux Foundation announced it in December 2025, with Anthropic’s Model Context Protocol (MCP), Block’s goose and OpenAI’s AGENTS.md as founding projects. Since then A2A has joined as a hosted project, and AAIF ran AGNTCon + MCPCon Europe at RAI Amsterdam a week earlier. On aaif.io the foundation invites people to “find your city” and to become an AAIF organiser.

The “Your local chapter” slide introduced AAIF Community Amsterdam as “EST. 2026, Amsterdam chapter” and “OPEN, vendor-neutral community”, “part of a global network” of chapters, with a row of local organisers (“the local champions”). A second slide, “Tonight’s hosts”, credited the AAIF Community Amsterdam team alongside the individual hosts.

The “Your local chapter” slide: AAIF Community Amsterdam, established 2026, open and vendor-neutral.

Laptops were open from the first minute, and the event T-shirts were piled on the chairs. That’s what you want from a hackathon kick-off.

The Nebius x NVIDIA Global AI Hackathon: rules, tracks, prizes

The hosts then switched to the hackathon deck: “Nebius x NVIDIA Global AI Hackathon: Build the next frontier of AI on open infrastructure”, tagged “Online · Public, open worldwide, subject to the official eligibility rules”, with a “Submit by Oct 30, 2026” button.

The hackathon briefing: online, public and open worldwide, with submissions due 30 October 2026.

Here is what the official rules say, checked on 3 October 2026:

• Submission period: 26 August 2026, 9:00 am PT, to 30 October 2026, 10:00 am PT.
• Core requirement: the project must “run on either Nebius Token Factory or Nebius AI Cloud” and use “at least one NVIDIA open source model”.
• What to submit: a working demo or test build URL (the main page exempts the Physical AI track), a public repository on GitHub, GitLab or Bitbucket with an open source license file (such as Apache 2.0, MIT or MPL 2.0) and a README with setup instructions, plus a demo video under three minutes.
• Judging: four equally weighted criteria: Technological Implementation, Design, Potential Impact and Quality of the Idea.

Four tracks

The “Four ways to build” slide matched the four tracks on Devpost:

1. Coding and Agentic Engineering: “Coding agents and developer tools that write, run, and test code in Token Factory Sandboxes.”
2. Best Apps and Agents: “Useful applications and agents powered by Nemotron models through Token Factory.”
3. Personal AI: “A private, always-on assistant with memory, reusable skills, and user-controlled tools.”
4. Physical AI: “Embodied and edge agents for robotics, IoT, simulation, and real-time inference.”

“Every project uses Nebius Token Factory or AI Cloud and at least one NVIDIA open source model.”

Prizes and the city tour

The prize slide promised “$50,000+ in prizes, plus NVIDIA Jetson Orin Nano kits for track winners”. The Devpost page lists the same structure:

The same slide put Builders & Brews: Hack Edition on a world map as a “20-city tour from Sep 9 to Oct 13”, from Tokyo and Seoul through Europe to the last stops in San Francisco (9 October) and Los Angeles (13 October). The $500 city prizes are what make a local build day worth turning up to.

Prizes and local build days: a 20-city tour from 9 September to 13 October.

Credits and a $1 certification

Two more slides covered getting started. “Join the AI Builder Program” offered “$25 Token Factory credit”, “$25 Tavily credit”, “Nebius certification for $1” and “Builder office hours & Discord”, behind a QR code. The “Get certified” slide showed a Nebius Certified Agentic AI Builder Associate badge: “Register today for just $1!”, with a certificate and Credly badge, and “free credits when you pass the exam”.

The submission checklist slide repeated the deadline (“Oct 30, 2026 at 10:00 AM PDT”) and the “required foundation” (Token Factory or AI Cloud, plus an NVIDIA open source model). Its one-line summary is worth pinning above your desk: “Show a working product, explain it clearly, and make the code available to judges.”

Nebius: Token Factory and serverless AI

The Nebius and Tavily slot (5:10 to 5:40 pm) listed Ivan Turasov and Marouane Khoukh from Nebius and Lakshya Prakash Agarwal from Tavily. The first part introduced Nebius Token Factory. Nebius describes it as the next evolution of Nebius AI Studio, and existing AI Studio users moved over automatically.

The “LLM Inference challenge today” slide set closed APIs (“fast to start, but zero customization”, “opaque performance and rate limits”) against self-hosting (“full control, but massive infrastructure burden”, “months to production”). “Neither option scales cleanly…” Its answer was “The Token Factory shift: dedicated open inference you can operate. Managed by us, controlled by you”, grouped under performance, cost and behaviour.

“The Token Factory shift”: dedicated open inference, managed by Nebius, controlled by the customer.

The rest of the Token Factory part, as shown on the slides:

• Positioning: “Deploy open-source AI on dedicated, zero-retention endpoints with 99.9% SLA and RBAC/SSO. Fine-tune and distill to cut $/token and latency. OpenAI-compatible by design.” The launch announcement makes the same claims: a 99.9% SLA, zero-retention inference in EU or US data centres, and fine-tuning and distillation pipelines.
• Data center locality: “Zero-Retention Inference” and “EU and US data centres support strict data-residency requirements”, on a map with Kansas City, New Jersey, Iceland, Finland, the United Kingdom, France and Israel.
• The console: a live view of the public endpoints (“Shared API endpoint, no deployment needed. Perfect for running tests, not production.”). The catalogue showed an NVIDIA Nemotron model next to DeepSeek, GLM and MiniMax models, plus a “Dedicated endpoints” card for “predictable latency, cost, and data control”.
• Post-training: full supervised fine-tuning (“works with smaller datasets (hundreds–thousands)”), LoRA adapters (“add/merge/remove skills easily”) and custom speculative decoder training (“use large model only to verify”).
• Company news: slides headed “Nebius agrees to acquire Eigen AI” and “Nebius welcomes Clarifai’s core team and licenses inference IP to strengthen Nebius Token Factory”, over an output-speed chart dated 14 March 2026. A customer slide, “Serving inference to the whole AI ecosystem”, grouped logos under hyperscaler and enterprise, AI-native and the open-source ecosystem (vLLM, Hugging Face, SGL, OpenRouter). These are Nebius’s own claims.

Then Marouane Khoukh, Developer Advocate at Nebius, took the “Nebius Serverless AI Deep Dive”. The one slide I could read from my seat during his talk was “Use preemptible VMs to cut costs: be ready that VMs can be preempted at any time”. It’s good advice for a hackathon budget, as long as your job can resume after a restart.

Marouane Khoukh, Developer Advocate at Nebius, opening the Nebius Serverless AI Deep Dive.

Tavily: “AI agents need the web”

Lakshya Prakash Agarwal, Forward Deployed Engineer at Tavily, opened with “AI agents need the web. But the web wasn’t built for them.” The slide showed raw JSON search results (title, url, content) for a car review query. Tavily’s slides now carry a “tavily by Nebius” logo: Nebius announced an agreement to acquire Tavily in February 2026, and that explains the joint Nebius and Tavily branding of the night.

The core slides:

• “Solving the web’s challenges for AI agents”: accuracy (“The web is a moving target, not a database”), information density (“Extracting relevant data for model reasoning”) and the speed barrier (“Sub-second latency for parallel agent tasks”).
• “How agents interact with the web”: three endpoints. /search takes a query and returns ranked URLs with content. /extract takes a URL and returns “Text / Markdown / Chunks”. /crawl takes a URL plus instructions and walks the link tree. A later slide added /map (“multi-threaded website exploration”). The Tavily docs also list a Research endpoint.
• “Where Tavily fits in the agent stack”: inside the agent harness, between the agent and the model providers, with OpenAI, Anthropic, Gemini, Mistral, NVIDIA and Hugging Face logos along the bottom.

“A research agent in ~30 lines. Reason + know = wired up.”

The slide that tied the evening together was “Where the layers click together”: User → LLM (Token Factory, “needs fresh data?”) → Tavily search() (“live web results”) → grounded answer, with “User → LLM → (decide to search) → Tavily → LLM → grounded answer with citations”. Three notes underneath: “Tool calling: native, OpenAI-compatible”, “~30 lines: no agent framework” and “Model decides: search isn’t hardcoded”. The closing slides listed use cases (“What Tavily helps you build”: coding agents, CRM enrichment, company research, fraud analysis, legal research and more) and “Fully Controlled Data Ingestion & Decisions”: human input, an open model on Token Factory, and Tavily’s /search, /extract, /crawl and /map.

Where Tavily fits: a tool inside the harness, not a model.

Remember that Best Use of Tavily is a separate $3,000 prize, and the Builder Program slide offered $25 of Tavily credit. Tavily’s Python quick start also gives 1,000 free API credits a month without a credit card.

Kilo Code: an open-source coding agent

The 5:40 pm slot on the agenda was Kilo Code, listed with Job Rietbergen, Head of Growth at KiloCode. The title slide read “Kilo Code: An open-source coding agent for every surface you work on”. “What Kilo is” made three claims: “One open-source agent that runs in VS Code, JetBrains, the CLI, Cloud Agents, and Slack”, “500+ models at provider cost, with zero markup and bring-your-own-key support”, and “5M+ Kilo Coders, processing 10T+ tokens every month”. The Kilo site repeats those numbers and says the project is MIT-licensed.

Kilo Code’s “Getting started”: one npm command for the CLI, Open VSX for VS Code forks.

The “Getting started” slide was the practical part:

• VS Code: search “Kilo Code” in Extensions, open the Install dropdown and choose Install Pre-Release Version.
• JetBrains: install from the JetBrains Marketplace.
• VS Code forks (Cursor, Windsurf, VSCodium): install from Open VSX.
• Sign in once and start with Auto Free, “which needs no credit card”.
• CLI: a single command, which matches the Kilo CLI docs:

npm install -g @kilocode/cli
kilo   # starts the TUI in the current directory

For the Coding and Agentic Engineering track, a coding agent that can point at an OpenAI-compatible endpoint is the obvious companion to Token Factory. Check that your agent setup can use the endpoint and model you plan to submit with. Kilo Code also pitched at the OpenClaw Hackathon at AI House Amsterdam in the spring.

The agenda continued with JetBrains (Bruno Lannoo, Senior AI/ML Engineer) and Moyai (Robert Hommes, founder) before the build session. My photos stop after the Kilo Code talk, so I can’t report on those.

How to build a hackathon agent fast

With four weeks to go and a requirement list that’s short but strict, this is the recipe I’d use. It’s my take, not the organisers’ advice.

1. Start with the 30-line loop, not a framework. The Tavily slide was right: an OpenAI-compatible model with native tool calling and one search tool is a working research agent. Token Factory’s quick start uses the standard OpenAI client with base_url="https://api.tokenfactory.nebius.com/v1/" and a NEBIUS_API_KEY. Here is my sketch of the loop on the slide. I haven’t run it against a hackathon account, so pick a model ID from the Token Factory catalogue (an NVIDIA open model, to satisfy the rules) whose card shows tool calling:

import json
import os

from openai import OpenAI
from tavily import TavilyClient  # pip install openai tavily-python

llm = OpenAI(
    base_url="https://api.tokenfactory.nebius.com/v1/",
    api_key=os.environ["NEBIUS_API_KEY"],
)
tavily = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
MODEL = os.environ["MODEL"]  # an NVIDIA open model from the Token Factory catalogue

TOOLS = [{
    "type": "function",
    "function": {
        "name": "web_search",
        "description": "Search the live web for recent or factual information.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"],
        },
    },
}]


def ask(question: str, max_rounds: int = 5) -> str:
    messages = [
        {"role": "system", "content": "Answer concisely and cite source URLs. Search when you need fresh facts."},
        {"role": "user", "content": question},
    ]
    for _ in range(max_rounds):  # hard cap on tool rounds
        msg = llm.chat.completions.create(model=MODEL, messages=messages, tools=TOOLS).choices[0].message
        if not msg.tool_calls:
            return msg.content
        messages.append(msg)
        for call in msg.tool_calls:
            query = json.loads(call.function.arguments)["query"]
            hits = tavily.search(query, max_results=5)["results"]
            snippets = [{"title": h["title"], "url": h["url"], "content": h["content"][:500]} for h in hits]
            messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(snippets)})
    return "Stopped: too many tool rounds."


if __name__ == "__main__":
    print(ask("What changed in the latest Kubernetes release?"))

The model decides when to search, as on the slide. The round cap and the snippet truncation keep a looping model from burning your $25 of credit.

2. Add structure only when the loop hurts. When you need several tools, sessions or a human approval step, move to a framework. My Google ADK SRE agent tutorial shows an LlmAgent with read-only function tools, MCP servers as tools and a guarded create_ticket tool that needs human approval. Before you commit to a framework, check that it can talk to an OpenAI-compatible endpoint such as Token Factory.

3. Make tools deterministic and testable without the model. Judges score technological implementation, and a demo that fails because a tool misbehaved is the worst outcome. In my Elastic Agent Builder MCP test I called every MCP tool with plain HTTP and no LLM. Do the same for your tools in CI, then let the model choose between them.

4. Expose it as a service if that fits your track. For Best Apps and Agents, an agent other agents can call is a stronger story than a chat box. The A2A Python SDK tutorial builds an A2A server with an Agent Card, a client and streaming task updates, and shows the “MCP inside, A2A outside” split.

5. Put a guard in front of anything that acts. For Personal AI (“user-controlled tools”) and for any agent that writes or sends, screen inputs and tool calls. Granite Guardian on Ollama shows a local Python gate for harm, jailbreak, groundedness and function-call checks. It runs next to your main model; you still need an NVIDIA open model for the hackathon itself.

6. Treat the submission as a deliverable from day one. Create the public repository with a LICENSE file (Apache 2.0 or MIT) and a README on the first day, not the last. Keep a running script for the video, which must be under three minutes. Pick your track early, because the Devpost page asks you to choose one and explain how the system works. The deadline is 10:00 am Pacific on 30 October, which is 6:00 pm in Amsterdam.

My take

Builders & Brews worked because it was short on theory and long on “here is the API, here is the credit, go”. The Nebius and Tavily talks fitted together: Token Factory for the reasoning layer and Tavily for the “know” layer. With Tavily now branded “by Nebius”, that pairing is the obvious default for this hackathon, and the Best Use of Tavily prize makes it pay. For my consulting work, the zero-retention and EU-residency points matter more than the prizes. They’re the same questions I hear from European teams about any hosted inference, so verify them against the contract, not the slide.

A new, vendor-neutral AAIF chapter in Amsterdam is good news too. The city now has the foundation’s conference at RAI and a local meetup to go with it.

Sunset over the old centre at 7:11 pm, with the build session scheduled to run until 10 pm.

Related

• A2A Joins the Agentic AI Foundation’s Open Agentic Stack
• AGNTCon + MCPCon Europe 2026: Two Days of Real Agentic AI at RAI Amsterdam
• OpenClaw Hackathon at AI House Amsterdam
• Google ADK SRE Agent: Tools, MCP and A2A in Python