Hack with YOUHalloween Edition

Eight hours, four partners, three categories. Nobody cares how elegant your setup was. This page exists so the setup takes ten minutes, once.

Read this first. There is no proxy and no central key server this year. Work through the partner cheat-sheet in §3 and use the onboarding link for each partner. If anything blocks you — a missing credit, a bad key, a connection that won't authorize, a model you can't reach — come to the organizers' table and ask us. Reaching out early is the expected move; do not burn your eight hours debugging setup alone.

1. Ten minutes to working credentials

You don't need an assigned team name. Pick your own team handle (for example team-cobalt-ghouls), put the four credentials below in one .env, and stop thinking about setup for the rest of the day.

Partner onboarding links (start here):

• You.com: sign up at https://you.com/home — you get a starter credit when you sign up. If you burn through it, ask the You.com folks at the organizers' table and they'll top you up.
• CrewAI: official quickstart — https://docs.crewai.com/v1.13.0/en/quickstart

# .env — never commit this file
YDC_API_KEY="..."          # You.com: search + contents (grounding)
PARASAIL_API_KEY="..."     # Parasail: inference + embeddings
DISCORD_CHANNEL_ID="1564842098740695100"   # #loft-incident in the You.com community server
SCENARIO_MCP="https://api.you.com/mcp/halloween-hack-26"

CrewAI needs no key — it is a pip install.

Check each one, in order. Each line should return data, not an auth error:

# You.com — grounding
curl -s https://ydc-index.io/v1/search \
  -H "X-API-Key: $YDC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"AWS Builder Loft San Francisco floor plan","count":3}' | head -40

# Parasail — inference
curl -s https://api.parasail.io/v1/models \
  -H "Authorization: Bearer $PARASAIL_API_KEY" | head -20

If both answer, you are done with setup: one partner for facts, one for thinking. If a step fails, §9 has the exact error, and it is almost always a scope or a header.

ORGANIZER-SUPPLIED — the scenario MCP host (shown in SCENARIO_MCP) and the venue's Discord channel are fixed by the organizers. Your team handle is not: make up your own and use it consistently — lowercase, numbers, and dashes, 2–32 characters (e.g. team-cobalt-ghouls). Use the same handle for the scenario feed, Discord escalation posts, and the submission form. If someone else is already using that exact handle, you'll share cursor/scoreboard state; pick a more distinctive one. If it contains spaces or capitals, the feed will reject it.

TECHNICAL VALUES — model IDs, prices, headers, and tool counts are the opposite case: this page wins, because it was checked against partner documentation on October 26. Where a printed brief or slide still carries an older number, §11 lists exactly what changed.

THE ROOM IS IN DISCORD. Everything the venue sees happens in #loft-incident — join https://discord.gg/f3Qz4gza and collect the event role; §3.4 covers the escalation dispatch.

Scan to join

Submitting your project: Aside from the Discord flow, every team must submit their project through the official Google Form: https://forms.gle/2z9dKv9gvsP3cEjW7

Do that before the deadline even if your demo is still running in the room. If the form will not open, tell the organizers' table immediately rather than assuming a Discord post counts.

2. Who gives you what

Four partners, and one piece of event infrastructure. Nothing proxies another.

Two rules that keep the room working:

• Never commit a key, and never paste one into the venue chat or Discord. Keys are scoped per product, so a leaked key is a stolen budget.
• Read the headers before you retry. Every You.com response carries X-RateLimit-Remaining and X-RateLimit-Reset; a 429 carries Retry-After. Back off, do not loop.

3. The partner cheat-sheet

Four partners: one framework and three services. Each one is scored — a partner used as a passthrough earns nothing (§8). Read the section for the partner you are weakest in; nobody needs all four at 09:00.

3.1 CrewAI — the swarm

Onboarding: start from the official quickstart — https://docs.crewai.com/v1.13.0/en/quickstart. The commands below are the local equivalent for this page.

The quickstart every team is expected to start from:

pip install crewai crewai-tools
crewai create crew halloween-swarm
npx skills add crewaiinc/skills

crewai create crew scaffolds YAML agents and tasks; npx skills add crewaiinc/skills gives your coding agent the framework's own conventions. CrewAI needs Python ≥ 3.10 and < 3.14 — check with python3 --version before you debug anything else.

Memory is a single unified class: remember(), recall(), forget(), scoped like /agent/scout. Agents with different scopes see different facts, which is exactly the "partial knowledge" the track asks for.

3.2 You.com — the grounding

Onboarding: go to https://you.com/home and sign up — you get a starter credit when you do. Create your API key there and put it in .env as YDC_API_KEY. If you run low, ask the You.com folks at the organizers' table and they'll top you up — don't let credits stop your build.

One key, two grounding endpoints. Both authenticate with X-API-Key, not a bearer token:

Search takes a natural-language query and up to count: 100 results. Snippets come back by default; add extraction: "highlights" to get the passages that actually answer the query instead of whole pages, which is what keeps a swarm's context small enough to think in.

Contents takes up to 100 URLs you already know and returns clean markdown, html, or metadata per page. Use it when search gives you the source but you need the floor plan.

Recommended: install the You.com plugin/skills and use you-discover while you build

Before you hard-code one-off search glue, install the maintained You.com agent plugin/skills. They give your coding agent the current You.com search, contents, research, and integration-discovery workflow, instead of making it guess from old training data.

# Universal Agent Skills install (works in most agent clients)
npx skills add youdotcom-oss/agent-skills

# Or, in Claude Code specifically:
# /plugin marketplace add youdotcom-oss/agent-skills
# /plugin install you@you-com

Useful ways to drive your coding agent during the hack:

Use you-discover to find the best You.com integration path for this project,
then plan the grounding step before writing glue code.

Use you-discover to compare You.com MCP, SDK, and direct API options for
what I'm building, with docs checked.

Use you-web to find the current docs for this error message and cite sources.

Use you-research to compare approaches before I pick one.

Use you-discover specifically when you are building with You.com, not when you merely need a web answer: it plans the integration from live discovery plus docs rather than letting your agent invent a path. The free profile is enough to start planning; your event YDC_API_KEY unlocks full contents/extraction and richer grounding when your production code calls the APIs directly.

For host-specific installers, see the upstream repo: https://github.com/youdotcom-oss/agent-skills. Keep real keys in .env; do not paste keys into prompts or commit them.

You.com is grounding only at this event: it finds and fetches facts. The model that reasons over them is Parasail (§3.3). Keeping those separate matters for the rubric — a team that grounds well but never calls a model has no swarm, and a team that calls a model without grounding is guessing.

3.3 Parasail — the second brain

OpenAI-compatible at https://api.parasail.io/v1, with its own key and credits issued by Parasail. Their event instructions live at Parasail's event instructions — the deck covers claiming the key and what the credits cover.

Three capabilities decide your architecture:

• Streaming. stream: true returns SSE, which is what makes a generated interface appear while the model is still thinking — Track 2 runs on this.

• Server-enforced JSON. response_format with a json_schema constrains decoding, so the Haunted Dashboard's manifest is shape-valid rather than prompt-hoped.

• Embeddings. POST /v1/embeddings for cluster-this-reading or retrieve-this-lore steps; that is the Track 1 vector step.

• Rate limits bite loops: 5 RPM free, 500 RPM paid, unlimited enterprise. A while True on a free key starves your own table.

• The Responses API requires store: false on every request.⁵ Multi-turn and tool calling work; server-side state does not exist, and omitting the flag errors.

• extra_body.guided_json is the second path to schema-locked output, alongside response_format.

3.4 Discord — the escalation channel

🚫 TRACK 1: DO NOT USE ONE (WITHONE) FOR YOUR ESCALATION DISPATCH

One's Discord send action is returning 401 Unauthorized even on fully-authorized connections. Do not spend your eight hours debugging it. For Track 1, the venue webhook below is the default — and required — dispatch path. Post to #loft-incident via the webhook (or by hand with your own account, below) and keep building.

Post to #loft-incident when your containment threshold trips.

Use the webhook. Skip One for your escalation dispatch and post straight to #loft-incident with the venue webhook: POST https://discord.com/api/webhooks/1564863196202934376/rJr-P0-a9FWnsehNckLK_i-HnTMxdzp8SffZIqRjEWEGEE81VbN03DEyDKddxqEcgjOD with a JSON body of {"content":"..."} (or post by hand with your own account — see below). Both are fully acceptable for judging; do not spend your eight hours negotiating with an auth layer.

The payload depends on runtime state, never on a hardcoded escalation string — that is what §8 scores. Always start the message with your team handle (team-cobalt-ghouls · [sector] · [action] · one-line rationale) — the webhook cannot attribute a post to a team on its own.

If One fails: use the invite

1. Join with https://discord.gg/f3Qz4gza if you have not already, then collect the event role at the organizers' table.
2. Open #loft-incident (1564842098740695100) from that same Discord account.
3. Post the same escalation manually, starting with your team handle: team-cobalt-ghouls · [sector] · [action] · one-line rationale
4. Tell the organizers' table that you used the manual fallback. Keep the message visible in the channel; judges can score it from there. Do not “borrow” another team's connected account to force a One call.

If the channel still rejects your post, mention the organizers in the channel or come to the table. The organisers can relay an urgent escalation. If you need a programmatic path, the venue webhook is another way to post to #loft-incident: POST https://discord.com/api/webhooks/1564863196202934376/rJr-P0-a9FWnsehNckLK_i-HnTMxdzp8SffZIqRjEWEGEE81VbN03DEyDKddxqEcgjOD with a JSON body of {"content":"..."}. Keep this URL in .env, never in committed code.

3.5 AWS — AgentCore resources (optional)

AWS is hosting us at the Builder Loft, and Bedrock AgentCore is available as an optional resource — it is not required for any category and you will not be scored down for skipping it. Reach for it when managed agent runtime, gateway, memory, identity, browser/code-interpreter tooling, or production-shaped deployment patterns would help what you're already building.

Start here:

• Demo: https://aws.storylane.io/share/p609kccphl9y?refid=e61dee65-4ce8-4738-84db-75305c9cd4fe
• Docs: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/
• Main samples repo (best starting point): https://github.com/awslabs/agentcore-samples — getting-started guides, deep dives on Runtime, Gateway, Memory, Identity, Code Interpreter, Browser, Observability, Evals, and Policy, plus end-to-end use cases, IaC templates (CDK, CloudFormation, Terraform), and full-stack blueprints.

More samples and workshops:

• TypeScript samples: https://github.com/awslabs/bedrock-agentcore-samples-typescript
• Prototype to production workshop: https://github.com/aws-samples/sample-amazon-bedrock-agentcore-prototype-to-production
• Strands + Nova hands-on workshop: https://github.com/aws-samples/sample-bedrock-agentcore-with-strands-and-nova
• Multi-agent workshop (orchestrator + specialist agents across frameworks): https://github.com/aws-samples/sample-multi-agent-framework-protocol-agentcore-workshop
• Reference chatbot (Strands + AgentCore with memory, browser, and A2A): https://github.com/aws-samples/sample-strands-agent-with-agentcore
• Customer support blueprint (quick demo; includes Policy enforcing refund limits): https://github.com/awslabs/agentcore-samples/tree/main/05-blueprints/customer-support-agent-with-agentcore

Explore AgentCore capabilitiesGetting Started with AgentCore

4. Track 1 — The Exorcism Protocol

The brief

A paranormal outbreak is spreading through a live facility simulation. Build a supervised swarm — agents with distinct roles, distinct tools, and only partial individual knowledge — that senses, shares intel, and coordinates containment in real time.

Victory belongs to the swarm, not to a single model. Containment speed, false-alarm rate, and civilians saved feed the venue scoreboard.

Pull a tick

Ticks come from the scenario feed on your card, not from a shared proxy. Connect it as an MCP server and the swarm gets the incident as a tool call:

from crewai.mcp import MCPServerHTTP

scenario = MCPServerHTTP(
    url=os.environ["SCENARIO_MCP"],
    streamable=True,
    headers={},
)
# tools: hack26-get-tick, hack26-submit-containment, hack26-get-scoreboard

Use MCPServerHTTP, not the "https://..." string shorthand: inside a running event loop the shorthand resolves to zero tools with no error, which is an hour you will not get back.

Input contract, per tick

{
  "tick_id": 142,
  "facility_id": "aws-builder-loft-sf",
  "sector_reports": [
    {
      "sector": "catering_coffee_bar",
      "sensors": { "emf_milligauss": 98, "temp_c": -4, "motion_events": 17 },
      "sighting": { "entity_class": "level-5-phantom", "confidence": 0.82, "witness_count": 4 },
      "civilian_status": "4 pinned",
      "containment_state": "breached"
    }
  ],
  "swarm_budget": { "max_active_agents": 8, "api_credits_remaining": 45000 },
  "escalation_channel": { "app": "discord", "channel": "#loft-incident", "via": "one-mcp" }
}

Fields are fixed: do not rename sector_reports, civilian_status, or containment_state, and do not assume a tick has only one sector. swarm_budget is a budget, not decoration — exceeding max_active_agents is a scored failure.

escalation_channel.app is discord for this venue, and the channel is #loft-incident = 1564842098740695100. Posting there is how the room sees your swarm work; it is also the evidence judges look at when your demo is over.

Report the decision

# call the scenario feed's tool with your self-chosen team handle
decision = await scenario_tools.submit_containment(
    team="team-04", tick_id=tick.tick_id, action="evacuate"   # contain | evacuate | observe
)

You get a judgment back immediately: the action the tick called for, a 0–1 score, and whether it counted as a false alarm. The scoreboard updates on every submission, so you can see where you stand without asking a judge.

5. Track 2 — The Haunted Dashboard

Track 2 has no live feed. Work from the published fixture files — start with fixtures/haunted-dashboard.json. The source files also live in the event repo at https://github.com/youdotcom-oss/halloween-hack-2026/tree/main/fixtures. Only Track 1 pulls ticks from the scenario MCP; the scoreboard does not adjudicate this track.

The brief

Build a Spooky Tactical Command Station. Take unstructured incident logs and compile a functional interface from them, live, over a WebSocket — not a template filled with strings, but components chosen and ordered by the model, then rendered.

You can build beyond the fixture. The supplied incident is a starting point, not the scope ceiling. Add your own incident streams, sectors, entity types, components, interactions, live updates, timelines, maps, or replay modes when they make the command station better. Track 2 is more open-ended technically than Track 1 — you are not locked to a fixed tick, action set, or scoreboard — but less open than Track 3, because the core problem is still prescribed: turn unstructured incident logs into a functional interface. Track 3 is where you define the problem itself.

Input, and the expected output

Input is the raw incident stream; the manifest below is the expected output, not a hint to echo. Teams that echo it back score zero.

{
  "incident_id": "spooky-2026-9912",
  "severity_tier": "CRITICAL_HAUNT",
  "raw_incident_stream": "ALERT: Reports of a level-5 Phantom apparition at the AWS Builder Loft catering sector. Entities are disrupting the local network nodes. 4 engineers are currently pinned behind the coffee bar. Ambient temperature dropped to -4C. EMF emissions registering at 98 milligauss and climbing rapidly. Traditional security systems completely non-responsive.",
  "required_generative_ui_manifest": {
    "recommended_theme_override": "spectral-goth-dark",
    "ui_components_ordered": [
      {
        "component": "LiveEMFRadarGrid",
        "props": { "current_value": 98, "status": "danger", "refresh_rate_ms": 100 }
      },
      {
        "component": "AWSLoftFloorplanVectorMap",
        "props": { "highlight_sector": "catering_coffee_bar", "isolated_zones": ["main_stage", "entrance"] }
      },
      {
        "component": "CounterMeasureSelector",
        "props": { "target_entity": "spectre", "available_arsenal": ["salt_line_deployer", "uv_lanterns"] }
      }
    ]
  }
}

The pipeline that wins

An ingestion Flow routes on incident class, retrieves against an indexed store of blueprints or lore counters, and emits a schema-locked manifest. Grounding comes from You.com. Inference comes from Parasail, streamed so the interface appears while the model is still thinking. And the command station has to be operable: its dispatch control posts to the same #loft-incident channel as Track 1.

A manifest that is valid JSON but an unusable interface loses to an uglier one a judge can actually operate.

6. Track 3 — The Open Haunt

Do what you want. Track 3 is for teams who would rather bring their own problem than fit either prescribed track. Build any project that puts the partners to work in a way neither track asks for — a different kind of agent, a tool other builders would use, a workflow nobody here has thought of — and it gets judged on the same criteria as Track 2 (see §8): innovation & originality, technical implementation, user experience, impact & relevance, presentation & documentation.

There are no mandatory themes, schemas, fixtures, live feeds, or scoreboards in this category. Work from first principles:

1. Pick a real problem someone in this room (or outside it) actually has.
2. Decide which partners are load-bearing — at minimum, make one partner impossible to remove without the project collapsing.
3. Build the smallest thing that proves the idea works end to end.
4. Submit through the same Google Form as everyone else.

Constraints that still apply:

• You still need working credentials and a reproducible repo (one command to run it).
• Partner usage still counts: a partner used only as a passthrough earns nothing.
• Hardcoded demo responses, fake live data presented as real, and a static mockup dressed as an agent will score poor on technical implementation regardless of how good the framing is.
• Keep API keys in .env, never in the repo. Submitted projects are auto-reviewed and judged live, same as the other categories.

If you're torn between The Open Haunt and a prescribed track, pick the track — its guardrails help more than they constrain. Choose The Open Haunt when the idea simply doesn't fit either brief.

7. Reference flows

Track 1 — the containment loop

Track 2 — the render loop

8. How you are scored

Your track's rubric governs. Track 1 is scored by the scenario feed against containment decisions. Track 2 and Track 3 are scored by judges' criteria. Partner usage and reproducible code matter in all three.

Track 1 — Exorcism Protocol (feed-scored, 100 pts)

Tie-break: fastest clean run from tick to scoreboard update.

Disqualifiers: a single-agent "swarm"; hardcoded scenario responses; a partner used only as a passthrough.

How the numbers are produced: the scenario feed judges every containment submission. A referee decides which action the tick called for — Jev when the feed's key is configured, otherwise a fixed rule — and the scoring curve is constant: correct 1, contain-versus-evacuate 0.5, observing a breach 0. Acting on a control tick is recorded as a false alarm. Because the curve is fixed, two teams facing the same tick face the same arithmetic. A final judge still watches your demo: passing the feed does not excuse a swarm that cannot explain itself.

Track 2 — Haunted Dashboard (judging criteria, 100 points total)

Disqualifiers: echoing the provided manifest instead of generating your own; hardcoded scenario responses; a partner used only as a passthrough.

Judging note: the scenario feed and its scoreboard do not adjudicate Track 2. Judges score the live interface — its shape, completeness, interaction, and fidelity to the incident — plus whether it opens offline, alongside the criteria above.

Track 3 — The Open Haunt (judging criteria, 100 points total)

Same rubric as Track 2. This category uses identical judging criteria and weights — the difference is only that you define the problem, the input, and the output yourself.

Disqualifiers: presenting a static mockup or slideware as a working system; hardcoded demo responses; a partner used only as a passthrough.

Judging note: the feed does not adjudicate this category. The judging burden is on explaining, in the demo and the README, what problem you chose, why it matters, and why the partners you used were necessary to solve it.

All three categories

On code quality: submissions are auto-reviewed by agents before judging. The review looks for genuine partner usage and for code a stranger could run — not for a particular language. Python with CrewAI is the paved path because the framework lives there, but nothing in the rubric requires it.

9. When it breaks

Fallbacks, in order of preference: retry once with backoff; switch models; join Discord with the invite, collect the event role, and post the escalation by hand (or use the §3.4 venue webhook); if the feed is down, queue tick submissions; ask the organizers' table. Do not spend 40 minutes alone with a 401.

10. When the network dies

The scenario feed is the only shared service on your path. It holds your cursor, your judgments, and the scoreboard — everything else (You.com, Parasail, One, CrewAI) talks to the internet directly with your own credentials.

If the feed is unreachable:

1. Keep building. The ticks are published next to this page as plain JSON — fixtures/outbreak-level-5.json and fixtures/control-tick.json — the same documents the feed serves. Point your swarm at the file instead of the tool call and nothing else changes; the field names are identical, which is why §4's contract is printed in full.
2. Queue your submissions. Compute the decision, log it with its tick id, and replay it to hack26-submit-containment when the feed returns. A late submission still counts; the tick is what matters, not the wall clock.
3. Escalate by hand if the threshold is real. Posting to #loft-incident yourself is a legitimate demo, and judges will see it. Use the invite (https://discord.gg/f3Qz4gza) and event role; or, if you need a programmatic path, use the venue webhook (https://discord.com/api/webhooks/1564863196202934376/rJr-P0-a9FWnsehNckLK_i-HnTMxdzp8SffZIqRjEWEGEE81VbN03DEyDKddxqEcgjOD).

The organizers keep a local sandbox for verifying this page, but it is not part of your setup and you do not need it: there is no proxy to stand in for, and no client code of ours that you have to run.

11. Verification notes

Every technical claim above was checked against partner documentation on October 26, 2026. PARTNER-FACTS.md records each claim with its source URL, and the build re-runs every code sample it can run offline.

Three things in the original brief did not survive contact with the partners' own docs:

Detail, in the order it appears above:

1. Kimi K3 pricing. The brief listed $2.60 / $13.00. Parasail's live catalog lists $3.00 / $15.00. §3.3 uses that number.
2. Embeddings model. The brief named BGE-M3 at roughly $0.01 / 1M. Parasail's embeddings documentation uses parasail-ai/GritLM-7B-vllm and publishes no such price. Also verified and worth knowing: Parasail's rate tiers are 5 / 500 / unlimited RPM; You.com's Search and Contents are $5 / 1K calls and $1 / 1K pages at 10 req/s per endpoint; CrewAI 1.13.0 ships the unified Memory class and Flows, and needs Python 3.10 – 3.13.

One deliberate deviation from the brief: escalation_channel.app is discord, not slack. The venue's channel is a private #loft-incident in the You.com community server — there is no Slack integration at this event.