GaryOS

Mentees are contributors landing real, mergeable pieces of the open system — everything goes in as a reviewed pull request against the same bar the rest of the project holds (read the code first, ground claims in evidence, drive the real path to prove it works before calling it done).

Concrete sample tasks:

• Write a new ingest plugin: fetch a public advocacy dataset, normalise it, choose a stable idempotency key so re-runs de-duplicate, and write it into the world-model through the mind's tool interface.
• Design and ship a new MCP tool-service (the standard "pure logic library + thin server + unit tests" shape) wrapping a capability the system doesn't have yet.
• Author a new sub-agent or event-triggered "skill" — e.g. a campaign-target discovery loop, a coalition-integrity check, a regulatory-comment drafter — and wire it into the live loop.
• Build a GaryOS starter template for a different org type or cause area, documented so it can be forked.
• Contribute to the strategy/goal-graph tooling (evidence validation, red-team passes, calibration) or the self-funding revenue layer (a metered agent-facing tool behind the payment gate).
• Research track: scope and prototype a piece of the continual-learning / predictive layer against the settled design doc — starting from the honest fact that nothing is trained yet.

Must-haves (any build track):

• Genuine commitment to animals. This is mission infrastructure — the judgment calls only go well if you care about the outcome.
• Comfort with Claude Code / LLM agents. The whole system is built with and around agentic coding — this is the tool you'll work in, and one entire track is authoring agents and skills for it.
• Docker / Docker Compose literacy at the "read a service definition, copy its pattern, add mine" level — you don't need to be a Docker expert.
• Git fluency and the temperament the project runs on: read before you rewrite, prove things work before claiming them, say "unverified" when you couldn't, surface a half-built seam loudly instead of hiding it, and self-direct on an ambiguous goal rather than waiting to be told.

Track-specific (nice to have — pick to your interest, you don't need all of these):

• Modern JavaScript / Node.js, n8n, Python/FastAPI, or Postgres/SQL generally — useful across several tracks.
• Research / ML track: classic ML — calibration, proper scoring (Brier), multi-armed and contextual bandits — and the judgment to not build a model until the data justifies it.
• Ingest / perception: consuming public HTTP APIs and normalising messy data; the idempotency instinct (a stable key so re-runs merge, not duplicate). Lowest barrier — best first contribution.
• MCP services: the Model Context Protocol SDK, Zod schemas, small-service design.
• Revenue layer: basic payment/crypto concepts (agent-to-agent micropayments, exactly-once settlement) and fail-closed security thinking.
• Mind / gate work: PostgreSQL with least-privilege roles, and the discipline to respect the mind's epistemic rules (you never fabricate the system's "experience" — that would poison its learning loop).

Above all: someone who finishes things. A shipped side project tells me more than a polished CV.

1. Which track pulls you most — ingest/perception, a new MCP service or agent/skill, an org/cause template, the revenue layer, or the ML/research direction — or what would you pitch instead, and why that one?
2. Point me at one thing you've built and shipped end-to-end (repo, demo, or write-up). What was the hardest part, and how did you know it actually worked?
3. What's your experience with agentic coding tools (Claude Code or similar), Node.js, n8n and Docker? Be honest about gaps — I'd rather calibrate the project to you than have you overstate.
4. What's your relationship to the mission — what drew you to animal advocacy?

• Domain expertise in AI-for-animal-advocacy — three years building it (agentic apps, workflow automation, training datasets, fine-tuned models, predictive analytics) and having taught it to ~2,000 people across developers and non-technical activists.
• Technical/architecture guidance — multi-agent design, MCP tool-building, deep-module design, and the specific hard problems in GaryOS: human-gated autonomy, world-modelling, self-funding, and evaluation.
• A real codebase to land in — a live open-source system with documented contracts for each contribution track, so a mentee has a concrete, reviewable place to ship rather than a blank page.
• Hands-on, adversarial review — I review code the way the project is built: evidence over assertion, verify before claiming, prefer a complete small thing over a half-built large one.
• Direction-shaping and accountability — helping scope a contribution that actually ships and matters over 10 weeks, plus weekly check-ins and a clear handoff so nothing stalls.
• Connections into the AI-for-animals community and prior collaborators where genuinely useful.