Does my screen data get sent to GitHub or the model behind Copilot?

The memory itself stays on your machine. What an agent actually pulls becomes part of that conversation. If the agent runs in someone else’s cloud, that conversation goes there. Connect only the agents you trust, and ask them for what you are willing to put in that thread.

Repository skills or personal skills?

Commit them under .github/skills when you want the whole team to have the same recall. Keep them in .agents/skills or a personal folder when it is only your machine. Either way each person needs LUCI running locally, because the memory is theirs.

Do I need to keep LUCI running?

For live history, yes. If LUCI is quit, the luci skill reads your Life folder instead. The memory only grows while LUCI is capturing.

Coding agent

Give GitHub Copilot Memory of Your Screen

Copilot knows the file you have open. It does not know the error you saw in the browser, or what the team settled on in the call. Install the official LUCI skills and Copilot can search both, from a memory that stays on this machine.

See all integrations

Copilot's agent mode reads your repository and calls tools. What it never sees is the half of your work that happens outside the editor: the failing request in the browser, the dashboard you stared at for ten minutes, the decision somebody made out loud on a call.

The official LUCI skills close that gap. Copilot supports the Agent Skills format, so the same two folders that work in Claude Code work here. Put them where Copilot looks and it can search your screen history and meeting transcripts on demand.

In VS Code, the chat.agentSkillsLocations setting controls which folders count, and it covers .github/skills and .agents/skills. Committing the skills under .github/skills is how you give a whole repository the same recall.

What GitHub Copilot can do with your memory

Search what happened outside the editor

Copilot can look up the exact error string from the browser console, the request that failed, or the log line you read on a dashboard, with the app, window, and time attached.

Repository-wide from one folder

Skills committed under .github/skills travel with the repository. Everyone running LUCI gets the same recall without setting anything up.

Meetings included

LUCI transcribes microphone and system audio locally, so Copilot can search what was said in the planning call while you write the code that came out of it.

Not scoped to one vendor

The same two skills serve Claude Code, Codex, Cursor, and the rest. The memory you build belongs to you, not to GitHub.

Try asking

Questions that work on day one

Search my screen memory for the failing test output from this morning
What was I looking at when this regression appeared?
Find where we discussed the schema change in today's call
What was I working on yesterday between 2pm and 4pm?

Set up GitHub Copilot

01
Turn on Screen Memory in LUCI
Install LUCI on your Mac or Windows machine, enable Screen Memory, and leave the app running.
02
Install the official skills
Ask Copilot to install them from the official repo, or run the installer from a terminal. Committing them under .github/skills shares them with everyone on the repository: https://github.com/Memories-ai-labs/Luci-skills
```
npx skills add Memories-ai-labs/Luci-skills
```
03
Confirm the skill locations
In VS Code, type /skills in the chat panel to open the Configure Skills menu and check that the folder you used is enabled.
```
"chat.agentSkillsLocations": {
  ".github/skills/**": true,
  ".agents/skills/**": true
}
```

Where GitHub Copilot looks for it

The two skill folders are ordinary files you own. Drop them where this tool reads and it finds them on the next session.

Repository skills: .github/skills/<skill>/SKILL.md
Other skill folders: .agents/skills/, per chat.agentSkillsLocations
Optional MCP file: VS Code's mcp.json
Written by the LUCI installer: Not directly. Claude Code, Cursor, and Codex are.

Frequently asked questions

The skills are ordinary Agent Skills folders, so any Copilot client that reads skills can read these. What matters more is where the memory lives. It is on your own Mac or Windows machine, so Copilot can only answer from it while it runs there. A cloud agent has no route to a memory sitting on your desk.