Forge 2 · Edition 2 — The Qualifier

One qualifier, two agents, one small build.

Forge 2 is about orchestrating a team of AI agents instead of typing every line yourself. This qualifier proves you can stand up that team and drive it. You will:

1. Set up OpenClaw — a coding agent you command from a chat channel (the hands).
2. Set up Hermes — an orchestrator with memory + a skill that can run on its own (the brain).
3. Wire both into Slack so every instruction and every agent reply is visible and you stay in the loop.
4. Have your agents build one small, real app — a tiny Trello-style Kanban board (Laravel API + React UI).
5. Push a public GitHub repo + deploy a live URL, then submit both.

The path

Everything here is free. Spend ₹0.

Before you start (10 minutes)

• Node.js 22.19+ (24 recommended) and Python 3.11+ installed. Check: node -v · python --version
• Git + a GitHub account. Create a new public repo now: forge2-qualifier-<yourname>
• A free Slack workspace (slack.com → Create a workspace). Slack is the only supported channel for this qualifier.
• One free model key — pick at least one: Groq (console.groq.com) or Gemini (aistudio.google.com), and/or Ollama (ollama.com) for fully-local.
• PHP 8.2+ & Composer (for the Laravel API) and a DB (SQLite is fine — zero setup).

A coding agent you drive from a chat channel.

Install

npm install -g openclaw@latest      # needs Node 22.19+ (24 recommended)
openclaw onboard                    # guided wizard: gateway, workspace, channels
openclaw doctor                     # diagnose any config/channel problems

Config lives in openclaw.json. You apply changes with config "patches".

Connect OpenClaw to Slack

Create a Slack app first (see §05 for the full Slack steps and the exact bot scopes). Then:

openclaw plugins install @openclaw/slack
export SLACK_APP_TOKEN=xapp-...     # app-level token, scope: connections:write
export SLACK_BOT_TOKEN=xoxb-...     # bot user OAuth token

cat > slack.socket.patch.json5 <<'JSON5'
{ channels: { slack: {
    enabled: true,
    mode: "socket",
    appToken: { source: "env", provider: "default", id: "SLACK_APP_TOKEN" },
    botToken: { source: "env", provider: "default", id: "SLACK_BOT_TOKEN" },
} } }
JSON5

openclaw config patch --file ./slack.socket.patch.json5 --dry-run   # preview
openclaw config patch --file ./slack.socket.patch.json5             # apply
openclaw gateway                                                    # run it

✅ Verify OpenClaw is right

• openclaw doctor reports no channel/config errors.
• With openclaw gateway running, you @-mention the bot (or DM it) in your Slack channel and it replies.
• You post a plain-English task (e.g. "write a Python script that prints the 10 most-recent files in this folder and run it") and the bot writes code, runs it, and posts the result back in the channel.
• The model you configured is actually being used — watch your model server/console logs while it answers. (Known OpenClaw issue #7211: a custom/local model can be configured but silently not used — confirm it's hit.)

An orchestrator that plans, remembers, and can run on its own.

Install

# Linux / macOS / WSL2
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
# Windows (PowerShell, native)
iex (irm https://hermes-agent.nousresearch.com/install.ps1)

source ~/.bashrc        # or ~/.zshrc / restart shell
hermes setup            # setup wizard
hermes model            # choose a (free) model provider — see §06
hermes                  # start the agent (TUI)

Give it the three things judges check

1. Memory

Tell Hermes a fact in one message ("our repo is forge2-qualifier-priya, default branch main"). In a later session, ask it to recall that fact. Hermes ships persistent memory + cross-session search — confirm it remembers without you re-pasting.

2. A skill (SKILL.md)

Create one reusable skill so a task type runs the same way every time. Minimal example committed to your repo at skills/status-report/SKILL.md:

---
name: status-report
description: Post a What I Did / What's Left / What Needs Your Call update to Slack.
---
When asked for a status update, gather: tasks completed, tasks remaining,
and any decision you need from the human. Reply in exactly three sections:
**What I Did** / **What's Left** / **What Needs Your Call**.

3. One autonomous run

Use Hermes' built-in cron to fire at least once without a manual prompt (e.g. "every 10 minutes, post a one-line progress update to #sprint-main"). Capture proof it ran on its own.

✅ Verify Hermes is right

• hermes doctor is clean; hermes model shows a free provider selected.
• Memory recall works across two separate sessions (not just within one prompt).
• Your SKILL.md fires automatically for its task type.
• A cron/event run posts to your channel with no human prompt.
• It decomposes a small goal into steps and posts the plan before acting.

Everything in the open. You stay in the loop.

Create the Slack app + bot token

1. api.slack.com/apps → Create New App → From scratch.
2. OAuth & Permissions → Bot Token Scopes, add at minimum: chat:write, channels:history, channels:read, app_mentions:read, im:history, users:read. (OpenClaw's Slack plugin lists more optional scopes — add them if it asks.)
3. Socket Mode → Enable (easiest on a laptop). It creates an App-Level token — give it scope connections:write, generate, copy the xapp-....
4. Event Subscriptions → Enable, subscribe to bot events: message.channels, app_mention.
5. Install to Workspace → copy the Bot User OAuth Token (xoxb-...).
6. In Slack, /invite @YourBot into your channels.

Channel scheme (use exactly these)

✅ Verify Slack is configured correctly (copy-paste test)

Run this round-trip — if all three succeed, your Slack wiring is correct:

export SLACK_BOT_TOKEN=xoxb-...
export CH=C0XXXXXXX            # your channel ID (channel → View details → bottom)

# 1) token valid?  -> {"ok":true,...,"user":"yourbot"}
curl -s -H "Authorization: Bearer $SLACK_BOT_TOKEN" https://slack.com/api/auth.test

# 2) can post?     -> {"ok":true,"ts":"..."}
curl -s -X POST https://slack.com/api/chat.postMessage \
  -H "Authorization: Bearer $SLACK_BOT_TOKEN" -H "Content-Type: application/json" \
  -d "{\"channel\":\"$CH\",\"text\":\"round-trip test ✅\"}"

# 3) can read?     -> JSON containing your message
curl -s -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
  "https://slack.com/api/conversations.history?channel=$CH&limit=5"

not_in_channel → invite the bot. missing_scope → add the scope and reinstall the app. Save these outputs (screenshot) — they are good submission evidence.

Pick free models. Route smart: a stronger model plans, a cheaper one executes.

All three speak the OpenAI Chat format, so any agent that accepts a base URL + key + model id can use them.

Recommended routing: Hermes (brain / planning) → a stronger model (Groq gpt-oss-120b or Gemini 2.5-flash); OpenClaw (hands / execution) → qwen2.5-coder on Ollama or Groq llama-3.3-70b. Be ready to say why you routed it that way — judges reward the reasoning.

# quick model sanity test (Groq example)
curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer $GROQ_API_KEY" -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-oss-120b","messages":[{"role":"user","content":"reply: ok"}]}'

Have your agents build a small Trello-style board. Laravel API + React UI.

This is the "real task" your two-agent system ships. Keep it small and working. You are the product owner: you describe it in #sprint-main, Hermes plans it, OpenClaw writes it, you review in chat.

Required features (must work)

• Boards → Lists → Cards. Create a board; a board has lists (e.g. To-Do / Doing / Done); a list has cards. Move a card between lists.
• Card details. A card has a title + description, and you can edit it.
• Tags / labels. Add coloured tags to a card (e.g. "bug", "design").
• Assign a member. Add people to the board and assign a card to one.
• Due date. Set a due date on a card; overdue cards are visually flagged.

Bonus (nice, not required)

• Email alert when a card is assigned or is due soon (Laravel Mail; a free SMTP like Mailtrap/Resend free tier, or log-driver email is fine for proof).
• Comments / activity on a card.
• Drag-and-drop between lists.

Tech constraints

• Backend: Laravel (PHP 8.2+), REST API, SQLite is perfectly fine (no DB server to manage).
• Frontend: React (Vite). Talks to the Laravel API.
• The code must be written by your agents through the chat loop — not hand-typed by you. You guide, review, and correct; the agents do the typing. That's the whole point.

Suggested first messages to your brain (Hermes) in #sprint-main

1. "Plan a tiny Trello-style Kanban: Laravel API (SQLite) + React (Vite).
    Entities: Board, List, Card, Tag, Member. Features: CRUD boards/lists/cards,
    move card between lists, tags, assign member, due date. Post the plan +
    task breakdown before writing any code."
2. (after you approve) "Assign task 1 to the coder. Have it scaffold the Laravel
    API with migrations + models + routes, run the migration, and report back."
3. "Now the React board UI that lists boards and renders lists/cards."
4. "Add tags, member assignment, and due dates. Show me a status report."

Everything we judge is read from your public repo. Make it complete.

Commit incrementally (not one giant commit). Your public GitHub repo must contain:

• README.md — what the app does, which models you used and why, exact run instructions (how to start the API + UI locally), and your live URL.
• ARCHITECTURE.md — which agent does what (brain vs hands), your Slack channel scheme, and your model routing.
• agent-log.md — the unedited log of your agents working (paste the key chat exchanges: human task → plan → code → report). This is required.
• slack-export/ (or screenshots) — proof of the chat loop, the autonomous run, and the Slack round-trip test output.
• skills/<name>/SKILL.md — the reusable skill you wrote for Hermes.
• openclaw.json + Hermes config (with secrets removed) and a .env.example listing the env vars (never commit real tokens/keys).
• The actual app: /backend (Laravel) + /frontend (React).
• evidence/walkthrough.mp4 (or a GIF): a 60 to 90 second screen-recording committed to the repo. No external video links.

We need a link we can open. Use any free host.

• React frontend → Vercel or Netlify (both free). Connect your GitHub repo, set the build dir to /frontend, deploy. You get a public URL.
• Laravel API → Render or Railway free tier (or any free PHP host). Point the React app's API base URL at it.
• Can't deploy the API in time? Deploy the frontend, and in your README give clear local-run steps for the API + a short video showing it working end-to-end. A live frontend + runnable backend + video still qualifies — a dead link with no fallback does not.

Submit your build — repo + live URL + evidence.

Done (or want to lock in progress)? Submit right here — you can resubmit while the qualifier is open and we score your latest entry.

Prefer a standalone page? Open the submission form ↗

Hybrid review: automated checks + human judging.

Every submission goes through a hybrid evaluation — automated analysis of your repo and evidence, combined with human review — scored out of 100. It rewards a clean, working two-agent setup and loop, not scale or flashiness.

Small bonus (up to +3) for working email alerts + card comments. To earn a seat you need a solid overall score and a genuinely working loop + running app — a polished repo with no working agents will not pass.

Pick free. Have a backup ready.

All of these speak the OpenAI chat format, so any agent that takes a base URL + key + model id can use them. Old Groq IDs (kimi-k2, old llama tags) are decommissioned — a tutorial that gives you one will fail with 400 model_decommissioned. Use the current IDs below.

When it breaks (and it will), start here.

Models & API keys

Ollama (local models)

OpenClaw (the hands)

Hermes (the brain)

Slack bot

GitHub & deploy

Skim these if a concept is new.

• OpenClaw — docs.openclaw.ai · repo
• Hermes Agent — hermes-agent.nousresearch.com/docs · repo
• Agent skills standard (SKILL.md) — agentskills.io
• Ollama — ollama.com · OpenAI compat: docs.ollama.com
• Free model keys — Groq console.groq.com · Gemini aistudio.google.com · openrouter.ai
• Slack apps — api.slack.com/apps · tokens: docs.slack.dev
• Laravel — laravel.com/docs · React + Vite — vite.dev/guide
• Deploy free — vercel.com · netlify.com · render.com

• Solo. You build your own submission. (Your app can have multi-user features — but the builder is you.)
• Eligibility: final-year / recent-grad builders per your invite. Open across India.
• Agents must do the coding through the visible chat loop. You orchestrate and review.
• Free stack only. No paid models or subscriptions.
• Honesty: real logs, real evidence. Zero tolerance for plagiarism, harassment, or misrepresenting others' work or AI output as a working setup when it isn't.
• Your code, your IP. NMG keeps a non-exclusive license to feature your build (with credit).

Stuck during the window? Post in the Forge channel — mentors are around. For anything else:

Forge Captain: Ayush Gupta · labs@nmgdigital.com · response under 24h.

→ Submit your build OpenClaw repo Hermes repo