OneContext

OneContext creates a shared project memory that gives AI assistants instant access to your project's context, reducing repetitive prompts and improving development productivity across all tools.

Comment

Inspiration

The idea for OneContext came from our experience working on college projects as a team. When several teammates work on the same application, each person may use a different AI coding assistant or follow a different approach. It became difficult to keep track of decisions, task progress, project files, and the reasoning behind previous work.

A teammate might plan a feature in ChatGPT, another might implement it with Codex, and someone else might continue in Claude without knowing the earlier discussion. This often led to repeated work, inconsistent decisions, and confusion about which files were already being changed.

We created OneContext to solve this problem by giving the entire team one shared project memory. It allows developers and AI agents to stay aligned around the same goals, decisions, tasks, and project context without forcing everyone to use the same AI tool. AI coding assistants are powerful, but each assistant usually has its own isolated conversation history. When teammates use Codex, Claude, Cursor, or GitHub Copilot on the same project, important decisions can become scattered across different chats.

We created OneContext to give the entire team one shared project memory. The goal is to help developers and AI agents stay aligned without forcing everyone to use the same tool.

What it does

OneContext provides:

  • A shared project brief, sources, decisions, and handoffs
  • Memory Chat for asking questions about the project
  • A knowledge graph connecting files, concepts, and decisions
  • A Chrome extension for transferring project context between ChatGPT and Claude
  • A VS Code extension for Team Codes, task intent, presence, and conflict warnings
  • Realtime collaboration across multiple laptops
  • An MCP server for Codex, GitHub Copilot, Cursor, and other agents
  • A Codex CLI workflow for retrieving project-aware context

A teammate can save a project handoff on one device, and another AI agent can retrieve it using the same project ID.

How we built it

OneContext was built with Next.js, React, TypeScript, PostgreSQL, and WebSockets.

Project sources are indexed into searchable chunks, while decisions, tasks, handoffs, file references, and activity are stored as structured project memory. The system retrieves relevant context instead of blindly copying complete conversations.

The Chrome extension uses Manifest V3 content scripts to add context to ChatGPT and Claude. The VS Code extension uses the VS Code API to track active files, publish task intent, show teammates, and save handoffs.

We also built a local MCP server that exposes tools such as:

  • onecontext_get_context
  • onecontext_check_conflicts
  • onecontext_publish_update
  • onecontext_save_handoff

Codex with GPT-5.6 accelerated the build by helping design the architecture, implement the backend and extensions, debug networking and MCP issues, improve the interface, create tests, package the VSIX, and prepare the final demo.

Challenges we ran into

The biggest challenges were making the system work across multiple tools and devices.

We had to debug:

  • Realtime communication between two laptops
  • Local Wi-Fi and firewall configuration
  • VS Code Extension Development Host behavior
  • VSIX packaging and versioning
  • MCP initialization and JSON-RPC communication
  • Gateway authentication
  • Chrome prompt detection
  • Preventing unrelated prompts from receiving project context

We also had to carefully decide what should become shared memory. Saving every raw chat would create noise and could expose private information, so we focused on concise project knowledge.

Accomplishments that we're proud of

We are proud that OneContext connects several independent workflows into one working system.

The project demonstrates:

  • ChatGPT-to-Claude project continuity
  • Shared memory between two laptops
  • Team Codes and live teammate presence
  • Conflict warnings for overlapping work
  • Persistent PostgreSQL project memory
  • A working Chrome extension
  • A packaged VS Code extension
  • MCP-based retrieval for AI coding agents
  • Privacy-aware storage of decisions and handoffs
  • A polished dashboard with sources, chat, graph, timeline, and settings

OneContext does not replace Git or any AI assistant. It gives the team a common context layer so everyone can work toward the same goal.

What we learned

We learned that useful AI memory should be selective and structured. Project goals, decisions, tasks, file references, and concise summaries are more valuable than storing entire conversations.

We also learned that provider independence is important. Teams should be able to use different AI assistants while still sharing the same project knowledge.

Finally, live presence is most useful as a coordination signal. It can warn teammates about possible overlap, but it should not act as a hard lock that prevents developers from working.

What's next for OneContext

The next steps are:

  • Deploy the web application and realtime service for remote teams
  • Add stronger authentication and project-level authorization
  • Support additional agents such as Claude Code, Cursor, Windsurf, and Antigravity
  • Improve semantic memory extraction and deduplication
  • Add richer file and symbol-level conflict detection
  • Add GitHub synchronization for private repositories
  • Add Redis-backed durable realtime presence
  • Provide project analytics and memory-quality controls
  • Improve privacy controls for individual memory items
  • Add production-grade audit logs and team administration

Built With

Share this project:

Updates