KONTEXT

Context synchronization for AI tools. Build once, use everywhere.

What is KONTEXT?

KONTEXT solves a fundamental problem: every AI tool requires its own context - skills, preferences, instructions - and keeping them all in sync is painful and error-prone.

KONTEXT is a universal context layer that syncs across AI tools. You define context once (skills, preferences, general instructions, tool-specific overrides), and it automatically propagates to all your connected AI tools. When you update context, it updates everywhere. No copy-paste, no drift, no manual sync.

The Problem

You're using multiple AI tools:

• Claude (Anthropic via their app or MCP)
• Cursor / Antigravity (AI code editors with MCP)
• ChatGPT (OpenAI's web and desktop)
• Gemini (Google's web and desktop)
• Windsurf (Flow's AI editor)
• 其他 AI 工具

Each tool needs:

• System prompts and instructions
• Your preferences and style guidelines
• Skills and capabilities you want them to have
• Tool-specific configurations

Currently, you manage these manually:

• Copy instructions into each tool
• Update one and forget to update others
• Drift between tool behaviors
• Lose context when tools reset
• Can't share strong capabilities across tools

This is fragmented, error-prone, and wastes your time.

How KONTEXT Works

1. Define Context

You create context files in KONTEXT:

• Base context: Default instructions, preferences, style that applies to all tools
• Skills: Capabilities, knowledge, workflows you want AI to have
• Tool overrides: Customizations for specific tools when they need different behavior

Context is stored as structured files (YAML, JSON, or Markdown) that are human-readable and versionable.

2. Connect Tools

KONTEXT integrates with AI tools through multiple channels:

• MCP (Model Context Protocol): Native integration for Claude, Cursor, Antigravity, and any MCP-capable tool
• Browser Extension: Injects context into ChatGPT, Gemini, and other web AI tools
• REST API: Programmatic access for tools that support HTTP
• CLI: Command-line interface for terminal-based tools

Each tool automatically receives its relevant context on connection.

3. Sync Automatically

When you update context:

• KONTEXT detects changes
• Propagates to all connected tools in real-time
• Logs sync activity for transparency

Tools receive updates instantly - no manual copying.

4. Use Everywhere

Every AI tool reads from the same context source:

• Claude uses your base context + Claude-specific overrides
• Cursor uses your base context + Cursor-specific overrides
• ChatGPT uses your base context + ChatGPT-specific overrides
• Behavior stays consistent across all tools

You build once. Tools use everywhere.

What KONTEXT Looks Like

Design

KONTEXT uses a neo-brutalist aesthetic - bold, distinctive, unapologetic. High contrast colors, sharp corners, visible structure. It stands out.

Colors:

• Primary: Burnt orange (#FF6B35)
• Background: Warm off-white (#F5F5F0)
• Dark mode: Near-black (#1A1A1A)
• Borders: Thick (3px), solid
• Shadows: Hard, offset (4px 4px)

Typography:

• Headings: Bold, chunky display fonts
• Body: Clean sans-serif
• Code: Monospace

Landing Page

The landing page introduces KONTEXT:

• Bold headline: "Context that actually works."
• Feature highlights
• "Works with" logos (Claude, Cursor, ChatGPT, Gemini)
• Code example showing context structure
• Clear CTAs: "Start Building"

Dashboard

The dashboard manages your context:

• Sidebar: Navigation (Context Files, Skills, Preferences, Connected Tools, Activity)
• Stats cards: Context files count, connected tools, last sync time, saved skills
• Recent activity: Table of context changes and sync events
• Connected tools: Grid of tools with status indicators
• Quick editor: Inline context file editing

How to Use KONTEXT

1. Install

Clone the repository and install dependencies:

git clone https://github.com/yourusername/kontEXT.git
cd kontEXT
npm install

2. Configure

Edit kontEXT.config.yaml to set your preferences:

• Default context location
• Sync behavior
• Connected tools configuration
• API keys (if using cloud features)

3. Create Context

Add context files to your context directory:

/context
  /base
    instructions.yaml    # Default instructions for all tools
    preferences.yaml     # Your preferences
  /skills
    coding.yaml           # Coding skills and workflows
    writing.yaml         # Writing capabilities
  /tools
    claude.yaml          # Claude-specific overrides
    cursor.yaml         # Cursor-specific overrides
    chatgpt.yaml        # ChatGPT-specific overrides
    gemini.yaml         # Gemini-specific overrides

4. Connect Tools

For MCP tools (Claude, Cursor):

npm run connect:mcp

For web tools (ChatGPT, Gemini), install the browser extension.

For CLI tools, use the command-line interface:

kontext read --file instructions
kontext write --file coding.yaml --skill new-skill

5. Use

That's it. Your AI tools now share context. Update once, it updates everywhere.

Core Features

| Feature | Description | |---------|-------------| | Universal Context | Define once, use everywhere | | Real-time Sync | Changes propagate instantly | | Tool Overrides | Customize per tool | | MCP Integration | Native support for MCP tools | | Browser Extension | Works with web AI tools | | CLI | Command-line interface | | Local-first | Your data stays on your machine | | Open Source | Self-host or contribute |

Architecture

Backend

• GraphQL API: Central data layer for context operations
• MCP Server: Provides context to MCP-capable tools
• SQLite Database: Local storage for context data
• Webhook Server: Event-driven pushes to registered tools

Frontend

• Landing Page: Marketing and onboarding
• Dashboard: Context management and monitoring
• Browser Extension: Web tool injection
• CLI: Terminal interface

Integrations

• Claude (via MCP)
• Cursor (via MCP)
• Antigravity (via MCP)
• ChatGPT (via browser extension)
• Gemini (via browser extension)
• Any tool via REST API

Status

KONTEXT is in early development. The codebase contains:

• Backend architecture design complete
• Frontend design direction selected
• Implementation planning done

Next steps involve:

• Building the GraphQL API
• Implementing the MCP server
• Developing the browser extension
• Creating the frontend dashboard

Why KONTEXT?

For AI Power Users

You're using multiple AI tools. You have preferences, instructions, and workflows that work for you. Keeping them synchronized is painful and error-prone.

KONTEXT fixes this. Build your context once. Use it everywhere. Stay in flow.

For Developers

You're building AI-powered applications. You need consistent context across tools. You want a unified layer.

KONTEXT provides this. Integrate once. Sync everywhere. Focus on building.

For Teams

You're sharing context between team members. You need consistent instructions across tools. You want to collaborate on context.

KONTEXT enables this. Share via git. Sync via KONTEXT. Stay aligned.

Contributing

KONTEXT is open source. Contributions welcome.

• Fork the repository
• Create a feature branch
• Make your changes
• Submit a pull request

Links

• GitHub: https://github.com/yourusername/kontEXT
• Docs: https://kontEXT.docs.example.com
• Issues: https://github.com/yourusername/kontEXT/issues

License

MIT License - See LICENSE file for details.