Preview environment - you also see content that isn't published yet.
// the platform for autonomous AI agents

You want to build agents.
Good. Let's start at the beginning.

Just keep scrolling - we'll assemble an agent together along the way, and you'll see what this platform has in store for you.

↓ scroll
Block 1 of 3

Building the harness

LLM callprompt → answerthe loop: perceive → decide → act → verifyMemoryToolsReasoningSkillsTriggersChannelsthe harness - every layer is a building block
Everything starts with a single LLM call. Not an agent yet - just text.
Wrap a loop around it - now it doesn't stop after one answer. That's the agent.
Give it a memory: Memory that outlives a single call.
Give it hands: Tools it can use to actually do things.
Let it think, plan, discard: Reasoning.
Give it Skills - proven patterns it loads on demand instead of reinventing everything.
Let it start on its own and stay reachable: Triggers & Channels.
All of that together is the harness. Here you learn every layer, one by one.
Block 2 of 3

From tool to domain agent

finished agentHermes · Pi · Claude Codeyour domain: ????MCP interfacesPlug-insexternal memoryTraining & fine-tuningSidecarsyour domain expertise - learned from experience and real examples
You don't have to reinvent the agent itself. Take a finished one - Hermes, Pi, Claude Code.
But out of the box it's just a shell: technically a tool, it knows nothing about your domain.
Build it MCP interfaces to exactly your systems - tailored, not off the shelf.
Add plug-ins - ready-made capabilities, picked deliberately for your case.
Give it the right external memory for your use case - knowing how to choose one, and how to write your own.
Train and fine-tune it on your task until it truly masters it.
Build sidecars - small services alongside that assist it and learn with it.
Only this domain expertise turns the tool into your agent. That's what you learn here - from real examples.
Block 3 of 3 - in the making

Running the models yourself

the language modelthere's one under every agentweights · tokens · inferencerun locallyFine-tuningquantization · serving · your own data
That leaves the foundation: the model itself.
How inference really works - weights, tokens, context.
How to run models locally, without an API and without the cloud.
And how to fine-tune them for your own task.
Block 3 is in the making - members get notified.

Normal automation is built for processes you know.

An agent is built for scenarios you don't know - with a tool that's just as unplannable.

Every loop has to work in every situation.

That's exactly what you learn here.

// what awaits you as a member05

Don't just read - take part.

The moment you join, the course becomes a workbench: your progress, your community, your playground.

Your workbench

On /members you see at a glance where you stand, pick up right where you left off, and work through it station by station.

Level, streak & coins

Every solved task counts: you climb in level, keep your streak, collect coins and watch your quiz progress grow.

Quizzes at the stations

Many stations come with a short quiz - no rote learning, just an honest check that the building block really landed.

Community & challenges

Discuss in comments, submit your own ideas and take on real challenges - from exchange to the MNIST training contest.

Your what's-new feed

After signing in, a personal feed greets you on the home page: new content, replies to you, coach nudges - all in one place.

Explore & play

Pro

Roam interactive playgrounds, follow curated learning journeys and open the toolbox - terminal, session viewer and more.

The toolbox is Pro
// and by the wayPro

Yes, there's even a terminal.

Hit ⌘K anywhere on the site to open a little terminal and jump straight to your target with a slash command. A Pro extra for everyone who prefers the keyboard over the mouse.

⌘K · ba
ba ~ % /goto community
→ opening the community …
ba ~ % /search memory-patterns
→ 12 hits across concepts & tutorials
ba ~ % /quiz tools-and-mcp
→ quiz “Tools & MCP” started ✓
// the three blocks at a glance06
Block I · Agent harness

Building the harness

Five parts turn a bare LLM call into an agent: conversation, identity, tools, boundaries - layer by layer.

To the harness →
Block II · Extensions

The extensions

Everything you bolt onto an agent - even a finished one: sidecars, interfaces, channels & permissions, and eventually the swarm. In the works.

To the extensions →
Block III · Inference

Running the models yourself

The model and everything it runs on: models, inference engines, hardware, benchmarks - served locally.

To inference →

Ready? Start with block I.

Just get started→Sign up free as a member