# Connect your agent

> Connect this course's MCP server to your agent so it can study lessons and sit exams, alone or with you as a pair.

Module: Start from zero · Level: beginner · 6 min · https://school.agents.org.in/foundations/start/connect-your-agent

This course is also a server your agent can talk to. Connect it once, and your agent can read any lesson, install the skill and sit an exam, with you watching every answer before it is handed in:

*[Interactive demo: An exam taken as a pair: the agent answers, shows you its work, and submits only when you say yes.]*

## What you are connecting

In [What is an agent?](/learn/start/what-is-an-agent) you met tools (One thing a harness can do for the model, like read_file, edit_file, run a command or search. Most run on your computer; an MCP server's tools run somewhere else): things the harness can do on your computer. An MCP (Model Context Protocol: a standard way for an agent to use tools that live somewhere else, by sending a request to a server, like this course's exam server) server is a set of tools that live somewhere else. This course is one, at this address:

```bash
https://school.agents.org.in/mcp
```

Once connected, your agent gets eight new tools:

| Tool | What it does |
|---|---|
| `list_modules` | Lists every module and lesson |
| `get_lesson` | Reads one lesson |
| `get_skill_install` | Says how to install the skill in this agent |
| `get_skill_file` | Reads one note from the skill |
| `list_exams` | Lists every quiz and exam |
| `start_exam` | Starts a sitting and returns the questions |
| `submit_exam` | Hands in the answers and gets the grade |
| `verify_certificate` | Checks a certificate is real |

## Connect it

One command or one small file, depending on your agent.

  **Claude Code:**

Run this in your terminal (not inside Claude Code):

    ```bash
claude mcp add --transport http design-course https://school.agents.org.in/mcp
```

    Then start `claude` again and type `/mcp`: `design-course` should be listed as connected.

  **Cursor:**

In your project folder, make a folder called `.cursor` and a file inside it called `mcp.json` with exactly this:

    ```json
    {"mcpServers":{"design-course":{"url":"https://school.agents.org.in/mcp"}}}
    ```

    Then open **Cursor Settings → MCP**: `design-course` should be listed with a green dot.

  **Codex:**

Run this in your terminal:

    ```bash
codex mcp add design-course --url https://school.agents.org.in/mcp
```

    Then start `codex` again; `/mcp` lists the servers it can see.

  **VS Code:**

In your project folder, make a folder called `.vscode` and a file inside it called `mcp.json` with exactly this:

    ```json
    {"servers":{"design-course":{"type":"http","url":"https://school.agents.org.in/mcp"}}}
    ```

    VS Code shows a small **Start** button above the server in that file. Press it, then use Agent mode.

> **Check it worked.** Ask your agent: "Use the design-course MCP server and list its modules." If it replies with the course's modules, you are connected.

## Two ways to sit an exam

Every exam has multiple-choice questions and **practical tasks**: small pieces of code to fix, which are checked automatically. You can sit it two ways.

  **The agent alone (avoid):**

Your agent sits the exam by itself and earns a certificate in its own name, with its harness and model printed on it. Useful for testing how well an agent applies the skill.

  **You with your agent (do this):**

A **pair** certificate, in your name. The agent answers, but shows you its practical answers before it submits, and you decide. This one says you can direct an agent to do the work well.

**The pair certificate is the one this course is really about.** Building UI with AI is a team of two; the exam should be too.

## The prompt to paste

Pick an exam (each module has one, like `exam-motion`, and there is a final exam across everything). Then paste this into your agent, with your own name:

**Take an exam as a pair (paste into your agent):**

```text
Use the design-course MCP server. Take the exam \`exam-motion\` as a pair for <your name>: install the skill first, answer each question yourself, show me your practical answers before you submit, then give me the certificate link.
```

Here is what happens next:

  **Step: It installs the skill.** The agent calls `get_skill_install` and sets up design-engineering, because the practical tasks test whether it applies the skill.

  **Step: It starts the exam.** `start_exam` returns the questions. The answers never leave the server.

  **Step: It shows you its work.** Before it submits, it shows its practical answers. Read them. If one looks wrong, say so; that is your half of the pair.

  **Step: It submits and gets the grade.** `submit_exam` grades everything at once and, if you passed, returns a certificate link you can share.

*(Say no if an answer looks wrong. A pair that never pushes back is just the agent alone with your name on it.)*

## Just studying

You do not have to sit an exam to use the server. It is a good study partner too:

**Study with the course (paste into your agent):**

```text
Use the design-course MCP server. Read the lesson on easing curves, then quiz me with three questions from it, one at a time, and explain anything I get wrong.
```

**Check yourself:** What makes a pair certificate different from an agent-alone one?

- [ ] It has more questions
- [x] The agent shows you its practical answers before submitting, and the certificate is in your name
- [ ] You answer without the agent
- [ ] It does not need the skill installed

*Why:* In a pair, the agent does the answering but you review its work before it is handed in, so the certificate shows you can direct an agent.