# Tools, skills and memory

Beyond the repository, you can give an agent tools (MCP servers), reusable
instructions (skills), agent plugins, access to your own servers, and lasting
rules it follows in every task (memory).

## MCP servers

MCP servers give the agent tools such as GitHub issues and pull requests, a
database, or a documentation search. Your server credentials stay with the
platform; the agent reaches your servers through a relay, with a token that
works only for the conversation's running turn.

### Connect a server

Open **My Settings → Plugins & MCPs**, or **+ → MCP servers → Add MCP** in the
composer. Pick a template such as **GitHub**, enter a server's address, or
import an `mcpServers` configuration. For GitHub, **Sign in with GitHub** needs
no token; a personal access token works too. Test the connection to discover
its tools.

### How conversations use them

Every server you connect is available to every conversation, new and existing.
Turn a server off for one conversation in **+ → MCP servers**; it stays off for
that conversation. Turning a server off or narrowing its permissions applies
at once; a newly available server appears with the conversation's next
message.

By default, each tool call waits for your approval. A waiting call shows in the
conversation and in **Approvals** in the header, which collects them across all
your conversations, with each call's server, tool, arguments and deadline.
**Open conversation** shows what the agent was doing when it asked.
**Approve** or **Deny** decides that one call. In the conversation's tools
panel, **Always allow** lets that tool run without asking again, in that
conversation only; the panel also lists the conversation's earlier calls.

A call nobody decides on expires after ten minutes and never runs; to go
ahead, have the agent try again and approve it in time. A call that ran and
then failed may still have taken effect: before retrying something that changes
things, such as creating a pull request, check whether it happened.

The platform also gives every task its own [memory](#memory) tools; they need
no connection.

## Skills

A skill is a set of instructions the agent applies when its description matches
the task, such as how to review a pull request. Manage your library in **My
Settings → Plugins & MCPs**: **Create skill**, import one from a GitHub URL, or
upload a `SKILL.md` file. You can mark skills as defaults for new chats.

Pick skills for a conversation with **+ → Skills**; a change applies to your
next message. A conversation can use up to 16 skills, and your library holds up
to 100.

## Plugins

To install agent plugins for a new chat, choose **+ → Plugins** before you send
the first message:

- **Claude Code and Codex** take `name@marketplace`, with the marketplace's
  GitHub repository or public HTTPS source.
- **pi, OpenCode and Kilo Code** take an npm package name, optionally pinned to
  an exact version such as `@example/plugin@1.2.3`.

You can add up to eight. The sandbox installs them before the agent starts; if
an installation fails, the turn stops with an error. Follow-ups and forks keep
the same plugins.

## SSH servers

SSH servers let the agent reach your own Linux machines with `ssh`, `scp` and
`rsync` — for example a GPU box. The platform creates a separate key for each
server; you add its public key to the server.

1. In **My Settings → Integrations → SSH servers**, choose **Add server** and
   enter a name (what the agent types after `ssh`), a host name or public IPv4
   address, the port and the username.
2. Choose **Check connection**: run the shown command on the server to install
   the key, read the server's host key, confirm its fingerprint, and test the
   login.
3. In a conversation, turn the server on in **+ → SSH servers**. It is
   available from the conversation's next turn.

Turning a server off, or deleting it, takes access away at once. After
deleting a server, also remove its key from the server's
`~/.ssh/authorized_keys`.

The agent can read the server's key and run any command that user may run, so
use a separate, low-privilege user. A server that limits who may connect must
allow FreeInference's machines. Only public addresses can be added.

## Memory

Memory is the lasting rules agents follow for you, such as "Use pnpm, not npm."
Agents save one when you ask them to remember something or correct how they
work, and you can write your own in **My Settings → Memory**.

- **User memory** applies to every project; **Project memory** applies to one
  repository and takes precedence.
- When a task starts, its repository's memories and your user memories are
  added before your request.
- Each scope holds 30 memories of up to 240 characters. When a scope is full,
  the least recently used memory an agent saved is archived; memories you wrote
  are never archived this way.
- Updating or deleting a memory archives the old one, and **Restore** brings it
  back. Archived memories are deleted after 90 days.
- **Use memory** turns a scope off: tasks no longer see its memories and agents
  save no new ones. **Clear** deletes every memory in the scope.