> ## Documentation Index
> Fetch the complete documentation index at: https://docs.remyx.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Quick Start
> Create your first experiment and connect Claude Code for AI-powered implementation
This guide walks you through creating an experiment, connecting Claude Code via MCP, and running an implementation. By the end you'll have a tracked experiment with a linked PR.
## 1. Set Up Your Profile
Your profile helps Remyx tailor recommendations to your work.
1. Click **Account** (bottom-left of the sidebar)
2. Set your **Role** (ML Engineer, Researcher, Data Scientist, Product Leader, etc.)
3. Add a one-line **Interests** description
4. Click **Save**
You can skip this and come back later under **Account > Profile Details**.
***
## 2. Create a Research Interest
Research Interests tell Remyx what to track across papers, repos, models, and more. Navigate to **Feed** in the sidebar and click **+ New Interest**.
| Field | What to enter | Example |
| ------------------------- | -------------------------------------------- | --------------------------------------------------------- |
| **Name** | Short label for this interest | "Retrieval-Augmented Generation" |
| **Context** | URLs or descriptions of what you're building | HuggingFace models, GitHub repos, arXiv papers, free text |
| **Daily Recommendations** | Resources per day (1-10) | 3 |
Click **Refresh** to get your first batch of recommendations immediately.
***
## 3. Create Your First Experiment
Navigate to **Outcomes** in the sidebar. Click **+ New Experiment**.
1. Set the **Source type** to **Paper**
2. Search for a paper relevant to your target repo
3. Fill in:
* **Name**: Something descriptive (e.g., "Multi-hop retrieval for complex queries")
* **Hypothesis**: What you expect (e.g., "Adding multi-hop retrieval will improve resolution rate for multi-topic queries")
* **Target metric**: e.g., `resolution_rate`
* **Tags**: e.g., `retrieval`, `rag`, `multi-hop`
* **Target repo**: `owner/repo` (e.g., `remyxai/VQASynth`)
* **Project**: Select or type one (e.g., `Customer Support AI`)
4. Click **Create**
You land on the experiment detail page. The **Origin** section loads the paper title and links immediately. Within a few seconds, the launch context appears: key method badges, abstract excerpt, Docker image, target repo, and an implementation plan grounded in your repo's actual file paths.
***
## 4. Install Claude Code and Connect Remyx
### Install Claude Code
```bash macOS / Linux theme={null}
curl -fsSL https://claude.ai/install.sh | bash
```
```powershell Windows (PowerShell) theme={null}
irm https://claude.ai/install.ps1 | iex
```
Verify the installation:
```bash theme={null}
claude --version
```
If `claude` is not found, open a new terminal window (PATH needs to refresh).
### Authenticate
```bash theme={null}
claude
```
This opens your browser. Log in with your Anthropic account (Pro/Max/Team/Enterprise). Follow the prompts to authorize. This is a one-time setup. Type `/exit` to quit when done.
### Add Remyx as an MCP Server
```bash theme={null}
claude mcp add --transport http remyx https://mcp.remyx.ai/mcp \
--header "Authorization: Bearer YOUR_REMYX_API_TOKEN"
```
Replace `YOUR_REMYX_API_TOKEN` with a personal (`rmxu_`) key created under **Account > API Access** in Remyx. See [API Scopes](/api-reference/scopes) for how keys and scopes work.
### Verify the Connection
```bash theme={null}
claude mcp list
```
You should see:
```
remyx: https://mcp.remyx.ai/mcp (HTTP) - Connected
```
You can also test from inside a Claude Code session:
```bash theme={null}
claude
```
Then type:
```
List active experiments from Remyx
```
Claude Code should call the Remyx MCP tools and return your experiments.
***
## 5. Run the Implementation
1. `cd` into your target repo
2. Start Claude Code:
```bash theme={null}
claude
```
3. Tell it to implement the experiment:
```
Implement the experiment "Multi-hop retrieval for complex queries" from Remyx
```
Claude Code fetches the experiment context via MCP, reads your repo files, generates the implementation, creates a branch, pushes it, and opens a PR. The PR is linked back to the experiment automatically.
Watch for permission prompts (git push, etc.) and approve them.
***
## 6. Check the Result
Refresh the experiment detail page in Remyx. You should see:
* A **green PR banner** at the top with the PR title, status, and GitHub link
* The PR listed in the **Resources** sidebar
* Events in the **Activity** feed (PR opened, implementation summary)
Click the PR link to review the code changes on GitHub.
***
## 7. Log a Decision
Once the experiment has results, log what the team decided and why. This is the most important step: it captures the reasoning that would otherwise live in someone's head.
Scroll to the **Decision** section and click to write:
> "Positive result, +3.1% on resolution rate. The re-ranker helps with multi-topic tickets where the old retriever returned tangentially related articles. Ship to production."
This decision is timestamped, attributed, and visible to the whole team. When someone new joins and asks "why do we use multi-hop retrieval?", the answer is here.
***
## 8. Check Insights
After creating several experiments with shared tags, navigate to **Insights** in the sidebar. Remyx groups experiments by tag, computes hit rates per direction, and shows which directions produce consistent results. It also recommends next experiments based on your team's history.
***
## Next Steps
Full guide to the experiment timeline and detail views
Connect GitHub, Linear, Jira, and Slack
The methodology behind systematic experimentation
See the [Feed](/platform/discover/feed) docs for how resource discovery and Research Interests work in detail.