// 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.

Join free as a member→Browse the concepts
↓ scroll
Block 1 of 3

Building the harness

Everything starts with a single LLM call: one question out, one answer back. Not an agent yet - just text.
After the answer it hangs up. So the harness keeps a transcript: the message history turns separate calls into a conversation.
Give it an identity: the system prompt sets role, tone and rules - before the very first word.
Give it hands - tools & loop: it proposes an action, the harness runs it and asks again. That loop is what makes it an agent.
Draw the boundaries: guardrails validate inputs, filter outputs and stop whatever must never happen.
These five parts together are the harness. Here you learn each one on its own.
LLM callprompt → answerMessage HistorySystem PromptTools & Loopthe loop: perceive → decide → act → verifyGuardrailsthe harness - five parts, layer by layer
Block 2 of 3

From tool to domain agent

You don't have to reinvent the harness for that: take a finished one - Hermes, Pi, Claude Code - or the one you built yourself in block 1.
But out of the box it's just a shell: technically a tool, it knows nothing about your domain.
Open your systems up to it via MCP interfaces - the hard part isn't the protocol, it's permissions, failure modes and a contract that still holds tomorrow.
Tool calling in production: a single tool call almost always works, twenty in a row almost never - the hit rates multiply.
Attach an external memory - the craft isn't storing things, it's deciding what travels along again on every request and what doesn't.
Context & tool selection: out of two hundred capabilities the model only sees the ones you show it - and the others' outputs flood its context.
Put sidecars beside it - services of their own for everything it shouldn't guess but get delivered reliably.
Only this domain expertise turns the tool into your agent. That's what you learn here - from real examples.
the harnessready-made or self-builtyour domain: ????MCP interfacesTool calling in productionexternal memoryContext & tool selectionSidecarsyour domain expertise - learned from experience and real examples
Block 3 of 3

Running the models yourself

That leaves the foundation: the model itself.
The mechanics first: how an LLM works - guess, append, repeat.
Which ones there are - open and closed, in every size.
What's inside a download: weights, tokenizer, chat template.
What turns that into an API: the inference engine.
What it all runs on - hardware and its hard memory limit.
And how to compare without trusting benchmarks blindly.
Six parts, all written - block 3 is ready to read.
the language modelthere's one under every agentHow an LLM worksModelsModel filesInference enginesHardwareBenchmarksopen weights · quantization · VRAM

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 & explainer videos

Many stations come with a short quiz - no rote learning, just an honest check. Short videos explain the building block before you build it yourself.

Community & submissions

Bring in your own ideas as a submission, pick up coach nudges and read along with what others wrote about a building block.

Writing comments yourself is Pro

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.

Parcours & challenges

Take on real tasks: in the training parcours your agent works on a simulated world, and the challenges go all the way to the MNIST training contest.

Past the gate, the tasks are Pro

The discover hub

/entdecken collects what deserves a second look: curated repos, small aha! pieces and the ways back into courses, news and community.

The toolbox

Pro

Terminal, session viewer, the agent arena with two reference agents on the same task, learning-path chat, deep dives in every building block and a progress tracker that keeps count.

The whole toolbox is Pro

Yours to keep

Pro

The tool-calling workshop volume as a PDF, the companion source kit for the Hermes creature and your referral link with QR code - 10 % off your own subscription.

These three start at 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 third tier

You want to run workshops yourself? Then become a Teacher.

Teacher is the tier for everyone standing at the front. It contains everything from Pro plus the tools for the room - from building the learning journey to the finished recording.

Teacher is the tier for companies and educational institutions: prices are net, plus VAT.

Look at Teacher→
  • Build learning journeys and share them with your group
  • Run decks: presenter view, window sync, timer, notes, print version
  • Whiteboard recordings: transcript, subtitles and a finished video in DE & EN - plus your own templates
  • Live polls in the room and the administration of your workshops
  • Two trainer volumes: teacher handbook (28 pp.) and AI licence trainer guide (78 pp.)
// the three blocks at a glance06
Block I · Agent harness

Building the harness

Five parts turn a bare model into an agent: the call, 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