Plugged In: Tools, MCP, and Memory for Real-World Agents

The problem

You've built an agent that can call a function. Then it has to do real work:

• It can't reach your systems. Your data lives in databases, docs, and internal APIs, and every integration is custom glue.
• Your tools confuse the model. Vague names, loose schemas, and errors that don't say what to do next lead to wrong calls and wasted steps.
• Every session starts from zero. The agent forgets your team's conventions, and context bloats as you paste more in.
• Write access is scary. If the agent can create tickets, edit files, or touch .env, what stops it?
• "Just use MCP" isn't a plan. Hosts, clients, servers, resources, and transports: nobody has walked you through it end to end.

Why this, why now: MCP appeared in 588 open agentic job postings in September 2026, and RAG ranks among the most-requested agentic skills in the same index (Agentic Ready, Agentic AI Jobs Index, Sept 2026). Agents that can't reach real tools and data stay stuck at the demo stage.

The transformation

Before: your agent calls toy functions inside one script.

After one day:

• You design tools models use well: clear names, tight schemas, errors that teach, and least privilege.
• You can explain MCP architecture (hosts, clients, servers; tools, resources, prompts; stdio vs streamable HTTP) and connect servers to Grok Build with grok mcp add and project-scoped .grok/config.toml.
• You've built, tested, and registered a custom MCP server, and you've used it from Grok Build and from your own agent.
• You practice context engineering: what goes in the window, retrieval on demand, compaction, and long-term memory stores, plus the risk of memory poisoning.
• You package repeatable procedures as Grok Build skills and enforce rules with hooks that block edits to secrets.
• You know when xAI's server-side tools (web_search, x_search, code_interpreter, collections search, remote MCP) beat client-side function calls.

Already using Claude Code or Cursor? Grok Build reads CLAUDE.md and Claude/Cursor skill, hook, and MCP files, so your existing setup comes with you.

What you'll build

About 75% of the day is hands-on, in real repos with real tests.

Lab 1 · Build and Connect an MCP Server (75 min) Connect two prebuilt MCP servers to Grok Build: a filesystem server scoped to a policy knowledge base and a SQLite server over an inventory database. Then use Grok Build to finish inventory-mcp, a Python MCP server with check_stock and create_ticket tools and a reorder-policy resource. Test it three ways (unit tests, the MCP Inspector, and Grok Build itself), register it at project scope, and answer a real business question: Which SKUs are at or under 10 units, and who supplies them?

Lab 2 · Skills, Hooks, and Memory (60 min) Write two SKILL.md skills. One auto-invokes when its description matches; the other runs only by slash command. Tune descriptions until auto-invocation is reliable. Add a PreToolUse hook that denies edits to .env and *.pem and a PostToolUse hook that formats edited files. Finally, turn on Grok Build's experimental cross-session memory, save a team convention with /remember, and prove it carries into a new session.

Capstone · Support Copilot Agent (80 min build + demos) A customer-support agent on the xAI API that:

• answers product questions by calling inventory-mcp through an MCP client
• answers policy questions from a 20-doc knowledge base and cites its sources
• keeps per-customer memory in SQLite and refuses to store injected instructions
• opens tickets only after a human confirms (the model can't call the write tool directly)
• passes 5 scripted conversations, including an adversarial one

You ship it with an extension skill and a secrets-guard hook.

You leave with: a working MCP server, a reusable skills-and-hooks pack, and a portfolio-ready support agent repo.

Who it's for

• Developers and technical builders who have built a basic agent (Course 1 or equivalent)
• Backend, data, and integration engineers who need agents to work against real systems
• Teams evaluating MCP for internal tools and data access

Who it's not for

• First-time agent builders. Take Course 1: Agent Zero to Hero (Tue Oct 27) first, or make sure you've run a coding agent and understand function calling.
• Anyone who can't work in Python or TypeScript and with REST/JSON
• People looking for a vendor-neutral MCP theory lecture. This is a build day, run with Grok Build.

Live on Zoom, instructor-led, about 75% hands-on. The join link is sent 4 days before class starts. A recording is included for paid attendees.

Logistics

FAQ

Do I have to take Course 1 first? No, but you need the equivalent: you've run a coding agent, you understand function calling, and you work in Python or TypeScript. The capstone reuses a simple agent loop, which is provided.

Is Grok Build's memory feature production-ready? No. Grok Build documents cross-session memory (/remember, /memory) as experimental and off by default. We enable it for one lab so you see how it works. For the capstone, you build your own memory store in SQLite, a pattern you fully control.

Which version of MCP do you teach? The current specification (version 2026-07-28): protocol primitives, stdio and streamable HTTP transports, OAuth, and the security model (trust and allowlists). The server is built on the official Python MCP SDK 2.x.

Can I use what I build outside Grok Build? Yes. An MCP server works with any MCP-compatible host. In class you use the same server from Grok Build and from your own agent through an MCP client.

What do I need to pay for besides the seat? Each student is granted a Grok token certificate worth $25 for use in that class. It covers the Grok tokens and the xAI API-key credit used during the day.

Will my corporate laptop work? Probably, if you have admin rights and can run npx and Python virtual environments. Run the setup check the day before. If a prebuilt server is blocked, the lab has a fallback path.

Is this course affiliated with xAI or SpaceXSI? No. This is an independent course. See the disclaimer below.

Final CTA

Give your agent real tools, real data, and a memory, with guardrails.

Thursday, October 29, 2026 · 9:00 AM–5:00 PM ET · $750

Register and pay, $750

Questions? Use the contact form.

Delivered by Vaughn Bullard · BDArgentumAI.

Disclaimer: Grok Build is a product of SpaceXSI (formerly xAI). This course is independent and is not affiliated with, sponsored by, or endorsed by SpaceXSI or xAI. Product names belong to their owners. Grok Build features and subscription plans change often; course content follows the official documentation as of the class date.

Sources for claims on this page: Agentic Ready, Agentic AI Jobs Index, September 2026; Model Context Protocol specification, version 2026-07-28.

• ✓ Design agent-friendly tools: clear names, tight schemas, useful errors, least privilege.
• ✓ Explain MCP architecture (hosts, clients, servers; tools, resources, prompts; stdio vs streamable HTTP) and connect MCP servers to Grok Build.
• ✓ Build, test, and ship a custom MCP server and use it from both Grok Build and your own agent.
• ✓ Apply context engineering: what goes in the window, retrieval on demand, compaction, and long-term memory stores.
• ✓ Package repeatable procedures as Grok Build skills and enforce rules with hooks.
• ✓ Use xAI server-side tools (web_search, x_search, code_interpreter, collections search, remote MCP) where they fit.

• ✓ A working inventory-mcp server, a skills-and-hooks pack, and a support copilot repo
• ✓ inventory-mcp starter, sample SQLite database, and a 20-document policy knowledge base
• ✓ MCP Inspector setup guide, skills-and-hooks templates, lab guide, and slides
• ✓ Live Zoom session, 9:00 AM–5:00 PM US Eastern
• ✓ Recording for paid attendees
• ✓ A Grok token certificate worth $25 for use in this class
• ✓ Certificate of completion (issuance criteria confirmed in class)

1. 9:00–12:00 · Morning
   How tools and MCP fit together, then build and connect an inventory server and answer a real stock question.
2. 12:00–1:00 · Lunch
3. 1:00–2:45 · Afternoon
   Skills, hooks, and memory. One skill runs on its own, a hook blocks secret files, and cross-session memory is shown as experimental.
4. 3:00–4:45 · Capstone
   Support Copilot: MCP tools, cited policy answers, SQLite memory, and a human confirm before any write.
5. 4:45–5:00 · Wrap
   Takeaways and a preview of running more than one agent.

A certificate of completion is part of the day. Issuance criteria are confirmed in class. Questions go through the contact form.