# EverMind × Beta Fund Workshop · 5/30 Hackathon

> 40-minute hands-on onboarding to EverOS for the Beta Fund × EverMind One-Person-Company Hackathon (Sunnyvale, 2026-05-30). Live deck: https://workshop-evermind-hackathon.vercel.app/

## Slide 1 — 40 minutes. Ship memory into your agent.
*Workshop · 10:30 — 11:10 AM · 40 min · Keep in Mind · Evolve over Time*

### 40 minutes. Ship memory into your agent.

Welcome to the Beta Fund × EverMind One Person Company Hackathon. This workshop skips the story — it's pure flow: from zero to EverOS, all the way to a working demo.

- 5/30 · Sunnyvale
- Solo / Small team
- $25K + Beta Fellowship
- 4 Tracks

Press → for step one · F fullscreen · Esc exit

## Slide 2 — Today you only do 4 things.
*Today's Path · Your 4 steps*

No ML degree, no GPU. A browser, an editor, and a cup of coffee.

- **01 / ACCOUNT — Sign up for EverOS Cloud** (~3 min) — Create an account; hackathon credit is auto-granted.
- **02 / API KEY — Generate your developer key** (~2 min) — Local and SDK calls both run on this key.
- **03 / HELLO — Make your first API call** (~5 min) — Pick curl, Python, or Node — see a response and you're through.
- **04 / EVEROS — Stand on 20+ templates** (~30 min) — Fork a ready use case → change 30% → submit.

**Core principle:** Today isn't about writing from scratch — it's about finding the closest template and making it 30% yours.

## Slide 3 — Sign up for EverOS Cloud.
*Step 01 · Account*

EverMind is your runtime and AI capability source for today. Sign up and your hackathon credit drops automatically — enough to last the whole day.

**What you'll get**

- **$50 hackathon credit** — Enough to run every demo and retry 5+ times on errors
- **Access to mainline LLM + agent orchestration APIs** — reasoning / tools / memory — the full set
- **Private fork access to the EverOS template library** — 20+ use cases, clone and go
- **Access to the Discord `#hackathon-may30` channel** — Stuck? @ a mentor here

Sign-up URL: `https://everos.evermind.ai/`

## Slide 4 — 3 key moves during sign-up.
*Step 01 · Detail*

- **Sign in with GitHub** — Fastest path; auto-links your commit history, no re-login when forking templates
- **Enter invite code `HACK0530`** — This code triggers credit issuance; without it you only get the $5 default trial
- **Skip the onboarding survey** — Top right corner — "Skip for now". Fill it out later this week.
- **Check your credit balance in the dashboard** — Top right should show $50.00. If not, @ a mentor immediately.

Dashboard URL: `https://everos.evermind.ai/dashboard`

**Common gotcha:** If GitHub login lands on a blank page, it's almost always third-party cookies blocked by your browser — switch to Chrome incognito or register with email instead.

## Slide 5 — Grab your developer key.
*Step 02 · API Key*

The API Key is the one credential your code and SDK use to talk to EverMind. 30 seconds in the console — this key opens every door that follows.

**The path**

- Dashboard → click your avatar (top right) → **Developer**
- Left sidebar → **API Keys**
- Top right → **Create new key**
- Name it `hackathon-may30`
- **Copy it immediately** — once you leave the page, you'll never see it again

API keys URL: `https://everos.evermind.ai/settings/api-keys`

Key format: `sk-em-•••••••••••••••••••••a7f3`

⚠ This key is shown only once. After closing this page, the full value can never be viewed again.

## Slide 6 — Put the API Key in the right place.
*Step 02 · Safety First*

This is the single most common way hackathon teams crash — key gets committed to a public GitHub repo, a bot scrapes it, credit zeroes out overnight.

**✓ The right way**

- Put it in a `.env` file at your project root — Format: `EVEROS_API_KEY=sk-em-xxxx`
- Add `.env` as the first line of `.gitignore`
- Read it in code via `os.getenv("EVEROS_API_KEY")`
- Redact or use placeholders before sharing code screenshots

```bash
# .env
EVEROS_API_KEY=sk-em-your-real-key-here
# matches `pip install everos` SDK · see docs.evermind.ai/cookbook/quickstart
```

```bash
# .gitignore
.env
.env.local
node_modules
__pycache__/
```

**True story:** Last hackathon, one team pushed their key to a public repo. GitHub's secret scanner caught it and revoked the key within 30 seconds — they had to re-issue it 3 times. **Always run `git status` before every commit.**

## Slide 7 — Two APIs. Just these two.
*Step 03 · Store your first memory*

EverOS makes "memory" into CRUD — `POST /memories` to store · `GET /memories/search` to query. 99% of what you'll use the whole hackathon is these two endpoints.

Endpoints: `POST /api/v1/memories` · `GET /api/v1/memories/search`

```python
# Real EverOS API · from github.com/EverMind-AI/EverOS README
import requests

API_BASE = "http://localhost:1995/api/v1"  # OSS local — for Cloud, swap in the endpoint from everos.evermind.ai

# 1) Store a memory
requests.post(f"{API_BASE}/memories", json={
    "message_id": "msg_001",
    "create_time": "2026-05-30T11:15:00+00:00",
    "sender": "user_001",
    "content": "I love playing soccer on weekends",
})

# 2) Search it back with natural language
res = requests.get(f"{API_BASE}/memories/search", json={
    "query": "What sports does the user like?",
    "user_id": "user_001",
    "memory_types": ["episodic_memory"],
    "retrieve_method": "hybrid",
})

print(res.json()["result"]["memories"])
```

```bash
# Real EverOS API · run this after the OSS deploy; for Cloud, use the URL from everos.evermind.ai
# 1) Store a memory
curl -X POST http://localhost:1995/api/v1/memories \
  -H "Content-Type: application/json" \
  -d '{
    "message_id": "msg_001",
    "create_time": "2026-05-30T11:15:00+00:00",
    "sender": "user_001",
    "content": "I love playing soccer on weekends"
  }'

# 2) Search with natural language
curl http://localhost:1995/api/v1/memories/search \
  -H "Content-Type: application/json" \
  -d '{
    "query": "What sports does the user like?",
    "user_id": "user_001",
    "memory_types": ["episodic_memory"],
    "retrieve_method": "hybrid"
  }'
```

```node
// Real EverOS API · Node 18+ has fetch built in
const API_BASE = "http://localhost:1995/api/v1";

// 1) Store a memory
await fetch(`${API_BASE}/memories`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    message_id: "msg_001",
    create_time: "2026-05-30T11:15:00+00:00",
    sender: "user_001",
    content: "I love playing soccer on weekends",
  }),
});

// 2) Search
const res = await fetch(`${API_BASE}/memories/search`, {
  method: "GET",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    query: "What sports does the user like?",
    user_id: "user_001",
    memory_types: ["episodic_memory"],
    retrieve_method: "hybrid",
  }),
});

console.log(await res.json());
```

**Success = POST returns 200 + search returns a non-empty memories array.** If you don't see it, first `curl http://localhost:1995/health` to confirm the server is up — if it's not, go back to Step 2 and check docker compose / `uv run python src/run.py`.

## Slide 8 — This is what a working memory looks like.
*Step 03 · What you should see*

EverOS isn't chat completion — it extracts raw content into structured memory with episodic / semantic / timestamps. Below is the real shape of a search response.

```bash
$ curl -X POST http://localhost:1995/api/v1/memories \
  -d '{"message_id":"msg_001","sender":"user_001",
      "content":"I love playing soccer on weekends",
      "create_time":"2026-05-30T11:15:00+00:00"}'

{"status":"ok","memory_id":"mem_8f3a..."}

$ curl http://localhost:1995/api/v1/memories/search \
  -d '{"query":"What sports does the user like?",
      "user_id":"user_001","retrieve_method":"hybrid"}'

{
  "result": {
    "memories": [
      {
        "memory_id": "mem_8f3a...",
        "type": "episodic_memory",
        "content": "I love playing soccer on weekends",
        "score": 0.91,
        "create_time": "2026-05-30T11:15:00+00:00"
      }
    ]
  }
}
```

**✓ Seeing this means**

- Docker stack is up (Mongo / Elasticsearch / Milvus / Redis — all 4 services healthy)
- `LLM_API_KEY` + `VECTORIZE_API_KEY` are both wired up
- You're clear to start stacking use cases — see Step 04

**✗ If you don't see it**

- `Connection refused` → server isn't running. Run `uv run python src/run.py`. Or confirm all 4 docker compose services are healthy.
- `500 + vectorize error` → `VECTORIZE_API_KEY` not set or wrong provider
- Empty memories array in the response → wait 5 seconds and search again; extraction has async lag

## Slide 9 — Stand on the shoulders of a SOTA memory stack.
*Step 04 · EverOS · The Memory OS for Agentic AI*

EverOS isn't a wrapper — it's the memory OS itself. Apache 2.0, Docker up, 4 infra services auto-wired (MongoDB · Elasticsearch · Milvus · Redis). Fork a real demo today, change 30%, and that's your product.

**Stats:** 5.6k GitHub Stars · 593 Forks · 80 Watching · Apache 2.0 License

**SOTA, open-source verifiable:** 93.05% LoCoMo · 83.00% LongMemEval · 93.04% HaluMem — see `evermind.ai/blogs/everos-hits-sota-performance-on-locomo`

```bash
# The real 6-step quick-start (from the GitHub README)
$ git clone https://github.com/EverMind-AI/EverOS.git
$ cd EverOS/methods/EverCore           # the runnable method lives here, not at repo root
$ docker compose up -d                 # spins up Mongo + ES + Milvus + Redis
$ curl -LsSf https://astral.sh/uv/install.sh | sh && uv sync
$ cp env.template .env                 # fill in LLM_API_KEY + VECTORIZE_API_KEY
$ uv run python src/run.py             # server starts on :1995
$ curl http://localhost:1995/health
→ {"status": "healthy", ...}
```

**Cloud path (zero Docker):** 6 steps feel like too many? Sign up at `everos.evermind.ai` — Cloud hands you a pre-wired endpoint + API key, and you skip straight past Steps 1–6 into the API.

## Slide 10 — Stand on 20 shoulders.
*Step 04 · 20 real demos · Pick the closest to your product*

- **Rokid AI Assistant** ([source](https://github.com/EverMind-AI/EverOS#use-cases)) — Glasses · soon
- **Creative Assistant** ([source](https://github.com/EverMind-AI/EverOS#use-cases)) — Tools · soon
- **Earth Online** ([source](https://github.com/xunyud/Earth-Online)) — Productivity · Code
- **Multi-Agent Orchestration** ([source](https://github.com/golutra/golutra)) — Infra · Code
- **Tasting Universe** ([source](https://github.com/Yangtze-Seventh/taste-verse)) — Personal · Code
- **EverOS Open Her** ([source](https://github.com/kellyvv/OpenHer)) — Persona · Code
- **Browser Agent** ([source](https://chromewebstore.google.com/detail/ruminer-browser-agent/lbccjohfpdpimbhpckljimgolndfmfif)) — Plugin · Chrome
- **EverMem Sync** ([source](https://github.com/nanxingw/EverMem)) — CLI · Code
- **MCO Coding Agents** ([source](https://github.com/mco-org/mco)) — Orchestrate · Code
- **Study Buddy** ([source](https://github.com/onenewborn/StudyBuddy-public)) — Self-evolving · Code
- **Alzheimer's Assistant** ([source](https://github.com/TonyLiangDesign/MemoCare)) — Care · Code
- **Multi-Agent NPC** ([source](https://github.com/AlexL1024/NeuralConnect)) — Game · Code
- **Mobi Companion** ([source](https://github.com/elontusk5219-prog/Mobi)) — iOS · Code
- **AI Wearable** ([source](https://github.com/JaMesLiMers/EvermemCompetition-Spiro)) — Hardware · Code
- **OpenClaw Agent** ([source](https://github.com/EverMind-AI/EverOS/tree/main/evermemos-openclaw-plugin)) — 24/7 · Plugin
- **Live2D + TEN** ([source](https://github.com/TEN-framework/ten-framework/tree/main/ai_agents/agents/examples/voice-assistant-with-EverMemOS)) — Voice · Code
- **Computer-Use Memory** ([source](https://screenshot-analysis-vercel.vercel.app/)) — Screen · Live
- **Game of Thrones** ([source](https://github.com/EverMind-AI/EverOS/tree/main/use-cases/game-of-throne-demo)) — Q&A · Code
- **Claude Code Plugin** ([source](https://github.com/EverMind-AI/EverOS/tree/main/use-cases/claude-code-plugin)) — DevX · Code
- **Memory Graph Viz** ([source](https://main.d2j21qxnymu6wl.amplifyapp.com/graph.html)) — Render · Live

All 20 from [github.com/EverMind-AI/EverOS#use-cases](https://github.com/EverMind-AI/EverOS#use-cases) · Click any tile to open the repo · Fork → 30% change → submit

## Slide 11 — From demo to your product.
*Step 04 · Fork → Modify → Ship*

EverOS ships runnable entry points like `demo/simple_demo.py` and `demo/chat_with_memory.py`. Pick the demo closest to your product, swap the prompts / sender / content, and you'll have a working version in 3 hours.

- **1. Fork the repo on GitHub** — github.com/EverMind-AI/EverOS → top-right Fork → your account
- **2. Get the local server running** — Step 04's 6-step quick-start · health endpoint returns healthy
- **3. Run a demo to verify** — `uv run python src/bootstrap.py demo/simple_demo.py` · watch a complete store-and-recall memory cycle
- **4. Modify the demo → your product** — Swap prompts · swap sender/user_id structure · plug in your frontend or data source
- **5. Record a 2:30 demo video** — Submit before 4pm · 2 slides + working product video (must show a working memory cycle)

```bash
# Terminal 1 · start the server
$ uv run python src/run.py

# Terminal 2 · run simple_demo
$ uv run python src/bootstrap.py demo/simple_demo.py

# Next level · interactive chat with memory
$ uv run python src/bootstrap.py demo/chat_with_memory.py
```

**Codespaces lifeline:** Docker not cooperating? In the README, click "Open in GitHub Codespaces" (pick 4-core or higher) — Mongo/ES/Milvus/Redis all spin up automatically.

## Slide 12 — 5 lessons last year's teams paid in blood for.
*Day Tips · Battle-tested*

1. **Demo first, features later** — By 11:30 you must have the ugliest possible version that runs. Reject every "just one more feature" temptation until you can demo.
2. **Record the demo — don't go live** — A 2:30 video can be cut and re-shot. Going live in front of judges on venue Wi-Fi = disaster. Finish recording before 3pm so you have time to edit.
3. **Team–problem fit beats technical flash** — "Why you're the one to build this" on slide 1 moves judges more than "which model we used."
4. **Social Media King is real cash** — Post on X / Jike / Xiaohongshu as you build, with `#onepersoncompany` and `@evermind`. 7 days later the cash actually lands.
5. **Stuck? @ a mentor immediately — don't suffer silently** — Mentors are on Discord `#hackathon-may30` and on-site. Every mentor wants you to ship — asking for help isn't embarrassing, not shipping is.

## Slide 13 — You need these 3 things at submission.
*Submission · 4:00 PM deadline*

- **Slide 1 · Team Introduction** — Name / school or company / relevant experience / team–problem fit
- **Slide 2 · Product Overview** — One-sentence pitch / the problem you're solving / the solution you built
- **Slide 3 · Demo Video** — 2 minutes max · must show a working product · no mockups
- **GitHub repo link** — Must be public (or add the hackathon org as a collaborator)
- **Live URL (if you have one)** — A link judges can try themselves is a massive scoring boost

**Day timeline**

| Time | Event |
|------|-------|
| 09:30 | Check-in & breakfast / team formation |
| 10:30 | Opening + Workshop (you are here) |
| 11:10 | Start building |
| 12:00 | Lunch (keep building) |
| 16:00 | **Submission deadline** |
| 16:00 | Demo round (3 min per team) |
| 17:00 | **Awards + closing** |

**The submission link** drops in the Discord `#hackathon-may30` channel at 3:00 PM sharp — bookmark the channel and turn on notifications.

## Slide 14 — Three prize tiers — every detail matters.
*Prizes · What you can take home today*

**🏆 Audience Favorite** (Awarded on-site, decided by audience vote, cash paid out at 5pm)

- 🥇 $600
- 🥈 $500
- 🥉 $400
- 4️⃣ $300
- 5️⃣ $200

**📱 Social Media King** (Paid 7 days later, judged on real reach of your demo / build log on social platforms over 7 days. Prizes paid via Discord.)

- 🥇 $500
- 🥈 $300
- 🥉 $200

**⚡ Beta Fellowship** (Grand prize)

- Direct admission to the Beta University 8-week accelerator — no standard application required.
- On project completion, Beta Fund invests **$25,000**.

**Strategy tip:** The three prizes reward different things — Audience Favorite is about live demo charisma, Social Media King is about your build-in-public skill, Beta Fellowship is about long-term investability. **None of them conflict — you can compete for all three at once.**

## Slide 15 — Real humans are waiting at every one of these.
*Need Help? · Where to go when you're stuck*

**💬 Discord — two of them**

- **Hackathon Discord** (your home today): team-formation · tech-support · submissions → `discord.gg/cswGFwFumn`
- **EverMind Discord** (official EverOS · long-term): Biweekly AMA · talk directly with maintainers → `discord.gg/gYep5nQRZJ`

**👥 On-site Mentor Desk**

- 📍 South side of the Workshop area
- 👋 Anyone wearing a gold badge is a mentor
- ⏰ On-site all day, 09:30 — 16:00
- On average, each mentor unblocks one team in 15 minutes.

**📖 Docs & code**

- `docs.evermind.ai/introduction` — API reference + both Cloud and Open Source paths
- `github.com/EverMind-AI/EverOS` — 5.6k stars · 593 forks · Apache 2.0
- `deepwiki.com/EverMind-AI/EverOS` — AI Q&A, multilingual, covers setup → advanced

**🆘 People**

- **EverOS Maintainer**: X `@elliotchen200` · GitHub `@cyfyifanchen`
- **Reddit**: r/EverMindAI
- **Email**: contact@evermind.ai
- Biweekly Discord AMA — talk to a maintainer directly.

## Slide 16 — Keep in Mind. Evolve over Time.
*Let's ship · build starts at 11:10*

### Keep in Mind. Evolve over Time.

You only have today. Don't aim for perfect — aim for "ready to show a judge." Memory is your unfair advantage.

**EverCore · SOTA benchmarks:** LoCoMo 93.05% · LongMemEval 83.00% · HaluMem 93.04%

**EverOS · three pillars:** Use Cases · Methods · Benchmarks

**Ecosystem links:**

- [X · @evermind](https://x.com/evermind)
- [HF · EverMind-AI](https://huggingface.co/EverMind-AI)
- [Discord · EverMind](https://discord.gg/gYep5nQRZJ)
- [WeCom · Community](https://github.com/EverMind-AI/EverOS/discussions/67)
- [GitHub · EverMind-AI](https://github.com/EverMind-AI)

**QR codes / quick links:**

- Event · Luma: `luma.com/h7h9r7bw`
- Hackathon Discord: `discord.gg/cswGFwFumn`
- EverOS Repo: `github.com/EverMind-AI/EverOS`
- EverOS Cloud: `everos.evermind.ai`

Workshop ends · Build time starts · See you at 4 PM demo round.

## Metadata

- **Slide count:** 16
- **Last updated:** 2026-05-24
- **Authoritative repo:** https://github.com/EverMind-AI/EverOS
- **License:** Apache-2.0
- **Live deck:** https://workshop-evermind-hackathon.vercel.app/