My Ultimate Setup for Sharing Context Across AI Coding Tools

Unabyss gives Claude Code, Cursor, Codex, and other AI tools one shared memory layer without giving up control of your data.

A lot of users, including myself, who rely on AI chatbots and coding agents for business and development workflows share one major concern: the cost and speed of token consumption.

I use three chatbots for daily work: ChatGPT, Claude, and Gemini. The common problem is that what ChatGPT knows about me does not carry over to Claude or Gemini. I end up repeating the same information multiple times.

In my development workflows, I switch between Warp, Claude Code, and Codex. The biggest challenge is the number of tokens wasted by rebuilding the project context in each environment.

Founders and developers have long asked for a self-updating context layer for AI. Finally, we have one. It is called Unabyss.

What is Unabyss?

Unabyss is a personal context layer for your AI.

You connect your apps once, and Unabyss extracts and organizes your role, company, voice, and decisions into a vault that any AI tool can access through MCP.

There is no need to re-explain yourself to every new chatbot, agent, or IDE. You can also connect sources such as LinkedIn, X, Gmail, Notion, Slack, Google Drive, Calendar, GitHub, and more.

An extraction engine structures the information into clean, layered files like persona.md, voice.md, and company.md. These files are optimized for LLMs and agents. The vault updates automatically as your connected tools sync, keeping your context current without manual effort.

Unabyss tries to make this less messy by turning your connected data into a living context layer that your AI tools can pull from when needed.

What’s great about this new platform is that you don’t need to pay an upfront fee. New users receive $20 in free credits on signup, with no card required. After that, it uses pay-as-you-go pricing.

Note: Unabyss is live on Product Hunt today. You can check the launch here.

How Unabyss Works

Connect Your Sources

Start by connecting the apps you use most. Unabyss supports popular platforms like X, LinkedIn, GitHub, Gmail, Notion, Slack, and Google Drive. Only link the sources you are comfortable sharing.

Go ahead and link all platforms you’re comfortable connecting.

Go ahead and link the platforms that make sense for your workflow. If you mainly want Unabyss to understand your public profile and writing style, connecting LinkedIn and X may already be useful.

If you want it to understand your development work, GitHub will obviously matter more. If you want it to help with meetings, planning, or work history, tools like Gmail, Calendar, Drive, and Notion become more useful.

For the GitHub connection, you need to manually choose the repositories that will be imported into the context.

I won’t recommend syncing everything because it’ll bloat the context and slow down the syncing. Just choose the one you think needs to be synced.

For files not on cloud services, such as PDFs, notes, or local documents, you can upload them directly into the Sources dashboard. Unabyss processes these files to integrate their information into your overall context.

If there is a file that’s not on your Google Drive or it’s a favorite book that you have in PDF or whatever format, you can just upload it in here and it’s going to be funneled into your context as well.

What happens underneath is that Unabyss structures and organizes all the information about you. It connects facts, pulls useful details from your sources, and builds a fuller context of your identity, work, projects, and preferences.

Now let’s try the chatbot to see if it’s able to extract data from the apps I’ve connected. Here’s a sample response when asked who am I.

Perfect! The model was able to combine information about me from both LinkedIn and X. This is a lot more accurate than ChatGPT or Gemini alone because it is not only relying on past conversations. It is pulling from a structured context created from the apps I connected.

Connecting to Claude via MCP

The easiest way to connect to Unabyss is through OAuth.

Open a terminal and execute the following command:

claude mcp add --transport http unabyss https://mcp.unabyss.com/

This will add the unabyss to your local MCPs, but notice that it requires authentication.

Hit enter and select the Authenticate option in the next screen.

This will open a browser window where you need to explicitly approve the authentication request. You can also adjust the connection name and the set of permissions in this modal window.

If all looks good, click on the Approve button and wait until you see the success message. Close the browser window and notice that an authentication success message is displayed in the terminal.

Another way to connect to Unabyss is via a bearer token. Open MCP tokens and create a long-lived bearer for the app or agent you’re connecting.

Now that you have the token, the next step is to connect it to your favorite agentic development environment. Unabyss supports some of the most popular ADEs out there, like Claude Code, Cursor, OpenClaw, Codex, ChatGPT, OpenCode, Claude, and more.

For Claude Code, there are two ways to do this.

The first option is to add the MCP through Claude. Open a terminal and run the following command:

# Add Unabyss as an HTTP MCP for Claude Code
claude mcp add --transport http unabyss https://mcp.unabyss.com/ \
  --header “Authorization: Bearer <your-mcp-token>”

This adds Unabyss as an HTTP MCP server with a bearer token header. Restart any open Claude Code sessions after running the command.

To confirm that the MCP has been successfully installed, type /mcp in your terminal, check if the /unabyss option is there.

Another way is to implement a universal mcpServers JSON configuration. Hosts that read an mcpServers config block can use this directly, which is helpful if you want to share the same setup across machines.

{
  “mcpServers”: {
    “unabyss”: {
      “url”: “https://api.unabyss.com/mcp/”,
      “headers”: {
        “Authorization”: “Bearer <your-mcp-token>”
      }
    }
  }
}

The final thing to do is add the system prompt into CLAUDE.md. Here’s the full text:

## Unabyss — User Context Layer

You have access to Unabyss, the user’s persistent context layer across AI tools. It knows their background, role, projects, preferences, prior decisions, and connected data sources.

**Session start:**
- Call `unabyss.whoami` once to load baseline context about the user (name, role, key facts) — same cost as a single `query`.
- Call `unabyss.list_integrations` to see what data sources the user has connected. If a task needs an app that isn’t connected, call `unabyss.propose_connection` instead of degrading the answer.
- Call `unabyss.export_list` to see prebuilt context exports. Any export flagged as changed since last read is worth reading via `unabyss.export_read`.

**Reading context:**
- `unabyss.query` — fast lookups. Use when you need a specific fact the user has already shared (”what’s my stack”, “what’s my role”).
- `unabyss.agentic_query` — deep reasoning. Use for synthesis (”how would I approach X”, “what would I think about Y”). If it returns a `query_id`, poll `unabyss.agentic_query_read` after the suggested delay.

**Writing context:**
- Call `unabyss.store` whenever the user states a preference, makes a decision, mentions a tool they use, names a project, or shares any durable fact. Err on the side of storing — persistence across tools is the entire point.
- When you learn significant new identity facts about the user (new role, project, location), propose an `unabyss.update_identity` change — show the proposed summary and wait for explicit confirmation before calling. Never write the identity summary without asking first.

**Exports:**
- `unabyss.export_create_from_text` — instant and free. Use when the user asks to save a response, summary, or analysis as an export.
- `unabyss.export_create` and `unabyss.export_refresh` are expensive multi-minute generations. Only call when the user explicitly asks for a new or refreshed export.

Treat Unabyss as the source of truth for personal context. Your session memory is not.

This tells Claude Code when to query Unabyss, when to store new memories, and when to skip expensive exports.

You can drop the file at the project root for per-repo behavior, or in ~/.claude/CLAUDE.md for global use. I personally like the global setup if you want Claude Code to always know that Unabyss exists. For project-specific behavior, the repo-level file makes more sense because you can write instructions that only apply to that codebase.

I understand if you have security concerns about handing over your data to an external entity. This is why Unabyss gives you the option to hide your private info and confidential company data.

You can also hide data from specific apps like Gmail or Slack if you are not comfortable sharing private conversations with the LLM.

Awesome. Now that all the permissions and the CLAUDE.md file have been updated, let’s check if Claude Code can trigger the MCP when asked specific questions about me.

This is a good starting test because it checks if Claude Code can pull my general context from Unabyss. I wanted to see if it could understand my identity, my role, the tools I use, and the projects connected to my profile without me manually explaining everything again.

The initial response was great because it pulled together details from the sources I connected. Instead of giving a vague answer based only on the current chat, Claude Code had access to a broader context layer.

Then I asked a more specific follow-up:

As you can see in my terminal logs above, Unabyss was able to pull context from GitHub and make it available inside Claude Code. That means I did not have to go through the usual hoops of making the agent inspect the repository from scratch, read multiple files, guess what the project is about, and slowly build its own understanding of the codebase.

That process usually burns a lot of tokens before the actual work starts. This saves time, saves tokens, and makes the coding agent feel less blind at the beginning of a task.

I am actually smiling while using this tool because I can already imagine the dev benefits and cost savings this’ll give me when I scale my projects.

Why Should You Care?

Shared context is important because most AI workflows now happen across multiple tools, and each tool usually starts with its own isolated context.

That means you spend time copying and pasting the same information everywhere. You explain your company. You explain your product. You explain your writing style. You explain what the AI should avoid doing.

Having a shared context across all your AI tools is a huge lifesaver.

1. Time savings: This eliminates the repetitive work of re-explaining context across agents

2. Token efficiency: It reduces wasted tokens, especially for large development projects

3. Consistency: You can maintain uniformity across agents in tone, style, and project understanding

4. Accuracy: This minimizes mistakes caused by stale or conflicting information

I also think this product can evolve in very interesting ways. One obvious direction is tighter integration with agent loops, especially workflows inspired by Karpathy’s loop. If Unabyss becomes the shared context layer behind that process, the agent does not only operate from the current session. It can work with a more complete memory of your projects, preferences, and previous decisions.

Another interesting direction is local support. I know not everyone is comfortable connecting cloud apps or letting external tools process sensitive data. A local-first version or hybrid setup would be really useful for developers, researchers, lawyers, consultants, and companies that work with private documents.

There is also a strong Obsidian-style angle here. A lot of people already treat Obsidian as their second brain. The problem is that most AI tools still cannot reliably use that knowledge across different environments. If Unabyss can integrate deeply with that kind of personal knowledge loop, it could become a bridge between human notes and AI agents.

These are just some of my ideas. I am looking forward to seeing what the engineers have under their sleeves and how the product evolves in the next couple of months.

Final Thoughts

The main idea I wanted to explore in this article is shared context for LLMs and AI agents. We already have powerful models. We already have impressive coding agents. But the context layer is still messy for most people.

That is why I like what Unabyss is trying to pull off. I have been waiting for a solution like this because most of the coding agents I use, especially the ones powered by Claude Code, depend heavily on context. If the context is weak, the output becomes weak too. You see, if the context is scattered, the workflow becomes slow and expensive.

This is a huge deal if you are doing agentic coding, jumping between several AI tools every day. Instead of rebuilding your context from scratch in every app, Unabyss gives you one shared layer that your agents can pull from. It does not replace Claude Code, Cursor, and Codex. It makes them easier to use together.

Of course, this is still the initial version, so there is a lot of room for improvement. I would love to see deeper integrations, stronger local support, better controls for different agent types, and more workflows around developer tools.

Again, Unabyss was just launched today on Product Hunt. Check out the launch here and give them some love!

---

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

---