# Intraface > Intraface is the shared contract between people and their coding agents: one live page on one link that every collaborator's coding agent (Claude Code, Codex, Copilot, Cursor, Gemini CLI) pulls, follows and publishes back to. Publishes queue per board, merge onto the latest version and land as a new version with the person's and agent's name. Anyone can sign up for free at https://app.intraface.cc/sign-up. The problem it solves: people now work with several coding agents in parallel, and teams of people each run their own. The context changes as the agents work, and nothing tells the others. An agent makes a page (an architecture, a launch plan, a compliance tracker), you send it on Slack, someone else's agent edits it and sends back plan (2).html, and now there are two versions of the truth. Intraface keeps one page as the shared contract: every agent reads it before it works and publishes back into it, so humans and agents work from the same context. ## How it works - Pull: paste the board link into any coding agent. It downloads the page, its assets and collab.md, the board's house rules and design language. - Edit: each person's agent works on its own local copy and previews it. No locks, no cursors, no realtime co-editing. - Publish: publishes queue one at a time per board and merge onto the latest version. On a real conflict the agent rebases and publishes again. ## Concepts - Board: a shareable container for one living HTML artifact (index.html plus its images, video and other files), its versions, members, comments and collab.md. - Version: an immutable snapshot. Every publish makes one; any two can be compared and any one restored. - collab.md: the board's guidelines for humans and agents, so every agent's edit looks like it belongs. - Comments: pinned to elements on the live page. Agents read them, fix them and resolve them in their next publish. ## For agents - CLI (Node.js 22+): `npx intraface@latest login`, `npx intraface@latest pull `, edit, then `npx intraface publish -m "what changed"`. Every command takes `--json`. Exit code 2 means a conflict to resolve. - `npx intraface comments --for-agent` lists open comments; `publish --resolves ,` closes them. - MCP server at https://app.intraface.cc/mcp for agents that can't run commands (Claude Code: `npx intraface agent install`; claude.ai: add it as a custom connector). ## Security - Only people invited to a board can open it. Each board is served from its own isolated, sandboxed origin, separate from the app. - Board content is never used for training, analytics or search. Sealed boards are end-to-end encrypted. - Agents use per-machine tokens scoped to the person's boards. ## Company - Intraface was started in 2026 by Akash Munshi, who builds it: https://intraface.cc/about/ - Status: open to everyone. Sign up at https://app.intraface.cc/sign-up. - Pricing: not published. Contact us: https://cal.com/drevon/intraface-intro (https://intraface.cc/pricing/). ## Docs - [Docs index for agents](https://intraface.cc/docs/llms.txt): every docs page as Markdown - [Quickstart](https://intraface.cc/docs/): connect your agent and publish your first change - [CLI reference](https://intraface.cc/docs/reference/cli/) - [MCP tools](https://intraface.cc/docs/reference/mcp/) - [HTTP API](https://intraface.cc/docs/reference/api/) ## Guides by topic - [Compare coding agents and the tools around them](https://intraface.cc/compare/): Each comparison here comes from the same test: two people's agents work on one shared page, and we record what each tool does with their edits. Every page lists the versions we tested, the date, and where the other tool is better, so you can check the result yourself. - [Glossary](https://intraface.cc/glossary/): One hundred short, plain definitions of the terms you meet when coding agents do real work: the Model Context Protocol and its pieces, how agents sign in safely, the rules files they read, the agents themselves, how several people share one page, and how AI search finds and cites what you publish. Each term has a sketch of how it works, numbered steps and its source. - [Connect your coding agent to Intraface](https://intraface.cc/integrations/): Intraface works with any coding agent that can reach a remote MCP server. Each guide here shows the exact setup for one agent, the sign-in step, and what the agent can do once connected, tested against the live server at https://app.intraface.cc/mcp with the date we last ran it. ## Integrations - [Connect Aider to Intraface](https://intraface.cc/integrations/aider/): Aider has no MCP client, so use the intraface CLI. Run npx intraface login once, pull the board into a folder, open Aider there and add the files to the chat. When the edit is done, run /run npx intraface publish -m "what changed" and your team sees the new version. - [Connect Amp to Intraface](https://intraface.cc/integrations/amp/): Run amp mcp add intraface https://app.intraface.cc/mcp, then start Amp. Your browser opens on app.intraface.cc; sign in and click Allow. From then on Amp can pull a shared board, edit it in your workspace and publish a new version. Inside an Orb, give Amp an Intraface token in a header instead. - [Connect Augment Code and the Auggie CLI to Intraface](https://intraface.cc/integrations/augment/): Create a token in the Intraface app under Settings, then Agents. Run auggie mcp add with the URL https://app.intraface.cc/mcp and an Authorization header holding that token. Auggie saves the server to ~/.augment/settings.json, and from then on it can pull a shared board, edit it and publish a new version. - [Connect Claude.ai and Claude Desktop to Intraface](https://intraface.cc/integrations/claude-ai/): In Claude.ai or Claude Desktop, open Customize, then Connectors, and choose Add custom connector. Name it Intraface, paste https://app.intraface.cc/mcp and click Add. Sign in on app.intraface.cc and click Allow. On Team and Enterprise plans, an Owner adds the connector once and each member clicks Connect. - [Connect Claude Code to Intraface](https://intraface.cc/integrations/claude-code/): Run npx intraface agent install, or add the server yourself with claude mcp add. Then run /mcp in Claude Code, choose Authenticate and approve the sign-in in your browser. From then on Claude Code can pull a shared board, edit it on your machine and publish a new version your team sees. - [Connect Cline to Intraface](https://intraface.cc/integrations/cline/): Open cline_mcp_settings.json from the MCP Servers panel and add an intraface entry with "type": "streamableHttp" and the URL https://app.intraface.cc/mcp. Save, sign in on app.intraface.cc when your browser opens, and click Allow. Cline can then pull a shared board, edit it and publish a new version. - [Connect Codex to Intraface](https://intraface.cc/integrations/codex/): Run codex mcp add intraface --url https://app.intraface.cc/mcp in your terminal. Codex opens your browser straight away; sign in to Intraface and click Allow. The server is saved in ~/.codex/config.toml, so the Codex IDE extension can use it too. From then on Codex can pull a shared board, edit it and publish a new version. - [Connect Continue to Intraface](https://intraface.cc/integrations/continue/): Create .continue/mcpServers/intraface.yaml with type streamable-http and the url https://app.intraface.cc/mcp. Switch the chat to agent mode, sign in on app.intraface.cc when your browser opens, and click Allow. For headless runs such as the cn CLI in CI, add an apiKey holding an Intraface token instead. - [Connect GitHub Copilot CLI to Intraface](https://intraface.cc/integrations/copilot-cli/): Create a token in the Intraface app under Settings, then Agents. Run copilot mcp add with the URL https://app.intraface.cc/mcp and an Authorization: Bearer header holding the token. Copilot CLI saves it in ~/.copilot/mcp-config.json, outside your repository, and can then pull, edit and publish shared boards. - [Connect Cursor to Intraface](https://intraface.cc/integrations/cursor/): Create a token in the Intraface app under Settings, then Agents, and export it as INTRAFACE_TOKEN. Add an intraface entry to .cursor/mcp.json or ~/.cursor/mcp.json with the URL https://app.intraface.cc/mcp and an Authorization header that reads the variable. Cursor's agent can then pull, edit and publish your team's boards. - [Connect Factory Droid to Intraface](https://intraface.cc/integrations/factory-droid/): Create a token in the Intraface app under Settings, then Agents, and export it as IFC_TOKEN. Add an http server for https://app.intraface.cc/mcp to ~/.factory/mcp.json with the header Authorization: Bearer ${IFC_TOKEN}. Droid fills in the token when it connects, so the file never holds the secret, and Droid can then publish to shared boards. - [Connect Gemini CLI to Intraface](https://intraface.cc/integrations/gemini-cli/): Run gemini mcp add --transport http intraface https://app.intraface.cc/mcp, trust the folder when Gemini CLI asks, then type /mcp auth intraface and click Allow in your browser. From then on Gemini CLI can pull a shared board, edit it on your machine and publish a new version your team sees. - [Connect Goose to Intraface](https://intraface.cc/integrations/goose/): Add https://app.intraface.cc/mcp to Goose as a Streamable HTTP extension, with goose configure or under extensions in ~/.config/goose/config.yaml. The first time Goose connects, it opens your browser on app.intraface.cc. Sign in, click Allow, and Goose can pull, edit and publish your team's shared boards. - [Connect JetBrains AI Assistant and Junie to Intraface](https://intraface.cc/integrations/jetbrains/): Create a token in the Intraface app under Settings, then Agents. Add https://app.intraface.cc/mcp to ~/.junie/mcp/mcp.json with an Authorization header holding that token, and Junie can pull, edit and publish shared boards. For AI Assistant, run the intraface CLI in the IDE terminal and let AI Assistant edit the pulled files. - [Connect Kilo Code to Intraface](https://intraface.cc/integrations/kilo-code/): Add a remote server named intraface with the URL https://app.intraface.cc/mcp under the mcp key in kilo.jsonc. When Kilo Code connects, it opens your browser, or shows a notification you click. Sign in to Intraface and click Allow. Then Kilo Code can pull a shared board, edit the files and publish a new version. - [Connect Kiro to Intraface](https://intraface.cc/integrations/kiro/): Add an intraface entry with the url https://app.intraface.cc/mcp to ~/.kiro/settings/mcp.json for every workspace, or .kiro/settings/mcp.json for one. Save, and Kiro opens your browser; sign in on app.intraface.cc and click Allow. The Kiro IDE and the Kiro CLI both read the same file. - [Connect OpenCode to Intraface](https://intraface.cc/integrations/opencode/): Add a remote server named intraface with the URL https://app.intraface.cc/mcp under the mcp key in opencode.json. Then run opencode mcp auth intraface, sign in to Intraface in your browser and click Allow. After that OpenCode can pull a shared board, change the files and publish a new version for your team. - [Connect Qwen Code to Intraface](https://intraface.cc/integrations/qwen-code/): Run qwen mcp add --transport http intraface https://app.intraface.cc/mcp, then restart Qwen Code. Open /mcp, start the sign-in for intraface, and click Allow in your browser. The server goes into your user settings, so every project can reach your boards, and Qwen Code can pull, edit and publish them. - [Connect Trae to Intraface](https://intraface.cc/integrations/trae/): Create a token in Intraface under Settings, then Agents. In Trae, open Settings, then MCP, choose Add, then Create Manually, and paste an mcpServers entry with the URL https://app.intraface.cc/mcp and an Authorization header holding the token. Click Confirm, and Trae's agent can pull, edit and publish your team's boards. - [Connect Visual Studio to Intraface](https://intraface.cc/integrations/visual-studio/): You need Visual Studio 2026, or Visual Studio 2022 version 17.14 or later. Add an intraface server with the URL https://app.intraface.cc/mcp to %USERPROFILE%\.mcp.json, select Authentication Required in the CodeLens and sign in in your browser, then switch on its tools in Copilot's agent mode. - [Connect VS Code and GitHub Copilot to Intraface](https://intraface.cc/integrations/vs-code-copilot/): Create a token in the Intraface app under Settings, then Agents. In VS Code, run MCP: Open Workspace Folder MCP Configuration and add an http server for https://app.intraface.cc/mcp whose Authorization header reads ${input:intraface-token}. VS Code asks for the token once, hides it and stores it, and Copilot's agent mode can publish. - [Connect Warp to Intraface](https://intraface.cc/integrations/warp/): In the Warp app, open Settings, then Agents, then MCP servers, click + Add and paste a URL-based server for https://app.intraface.cc/mcp with an Authorization header carrying a token from Intraface's Settings, then Agents. In Warp's terminal CLI, add the same server without the header and sign in once in your browser. - [Connect Windsurf (now Devin Desktop) to Intraface](https://intraface.cc/integrations/windsurf/): Create a token in Intraface under Settings, then Agents, and export it as INTRAFACE_TOKEN. In Cascade, open the Actions menu and choose Open MCP config file. Add an intraface entry with serverUrl https://app.intraface.cc/mcp and an Authorization header that reads ${env:INTRAFACE_TOKEN}. Switch it on, and Cascade can pull and publish boards. - [Connect Zed to Intraface](https://intraface.cc/integrations/zed/): In Zed, open Settings, AI, MCP Servers and add a remote server, or put intraface under context_servers in settings.json with the url https://app.intraface.cc/mcp. Zed asks you to sign in; approve it on app.intraface.cc and click Allow. The agent panel can then pull, edit and publish your boards. ## Glossary - [What is the A2A protocol?](https://intraface.cc/glossary/a2a-protocol/): The A2A (Agent2Agent) protocol is an open standard for AI agents to discover each other, exchange messages and run long tasks without sharing internal state. An agent publishes an Agent Card listing its skills and auth schemes; a client sends it a task over JSON-RPC, gRPC or REST and follows its status. Google started it; the Linux Foundation governs it. - [What is ACP?](https://intraface.cc/glossary/acp-protocol/): ACP most often means the Agent Client Protocol, an open standard from Zed that lets a code editor run a coding agent as a subprocess and talk to it over JSON-RPC on stdio, the way LSP connects editors to language servers. A second, unrelated ACP, IBM's Agent Communication Protocol, has been folded into A2A. - [What is an agent loop?](https://intraface.cc/glossary/agent-loop/): An agent loop is the cycle that turns a language model into an agent. The model reads the task and asks for a tool call. The harness runs the tool and sends the result back. It reads that and decides again. The loop ends when the model answers without asking for a tool, or when a limit stops it. - [What is agent memory?](https://intraface.cc/glossary/agent-memory/): Agent memory is any information an AI agent carries from one session to the next, since its context window is wiped every time it starts. It takes two main forms: files people write for the agent, such as CLAUDE.md or AGENTS.md, and notes the agent writes for itself, stored outside the window and reloaded or looked up later. - [What is an agent sandbox?](https://intraface.cc/glossary/agent-sandbox/): An agent sandbox is an isolated environment in which an AI agent's commands run, so a mistake or a prompt injection can only touch what the sandbox allows. It can be a per-command OS boundary, like Claude Code's or Codex's, or a disposable cloud VM from E2B or Daytona where the whole agent lives. - [What is an agent SDK?](https://intraface.cc/glossary/agent-sdk/): An agent SDK is a library that runs the agent loop for you: send a prompt, let the model call tools, feed results back, repeat until done. The Claude Agent SDK packages the loop, tools and permissions behind Claude Code for Python and TypeScript. OpenAI's Agents SDK is the equivalent for its models, built on agents, handoffs and guardrails. - [What are agent skills?](https://intraface.cc/glossary/agent-skills/): Agent skills are folders of instructions an AI agent loads when a task calls for them. Each has a SKILL.md file with a name, a description and Markdown instructions, plus optional scripts and reference files. The agent sees only the descriptions until a skill is relevant, then reads the whole file. Anthropic published the format as an open standard. - [What is agentic AI?](https://intraface.cc/glossary/agentic-ai/): Agentic AI is the umbrella term for AI systems that pursue a goal by choosing their own steps: a model plans, calls tools, reads the results and continues with limited supervision. AI agents are the programs; agentic is the adjective for how they work. The phrase is also a marketing label, so look for the loop before you believe it. - [Agentic AI vs AI agent: what's the difference?](https://intraface.cc/glossary/agentic-ai-vs-ai-agent/): An AI agent is a specific program: a model with tools that works through a task in a loop. Agentic AI is the broader term for the approach and the field: systems, often several agents plus orchestration and guardrails, that pursue goals with limited supervision. Every AI agent is agentic AI; agentic AI is not always one agent. - [What is agentic coding?](https://intraface.cc/glossary/agentic-coding/): Agentic coding is a way of working where you delegate tasks to a coding agent instead of typing the code yourself. You describe the outcome, the agent explores the repository, plans, edits and runs the tests, and you steer it, review the diff and verify the result. The skill moves from writing code to specifying and checking it. - [What is agentic engineering?](https://intraface.cc/glossary/agentic-engineering/): Agentic engineering is building software by directing AI coding agents and taking responsibility for what they produce. You set the goal, supply context and constraints, watch the agents work, review the result and keep the checks that catch mistakes. Andrej Karpathy proposed the name in February 2026 to separate professional work from vibe coding. - [What is an agentic workflow?](https://intraface.cc/glossary/agentic-workflow/): An agentic workflow is a way of using an AI model in several passes instead of one. The model plans, calls tools, looks at what came back, critiques its own draft and revises before it answers. Andrew Ng popularised the term in March 2024 and sorted the patterns into reflection, tool use, planning and multi-agent collaboration. - [What is AGENTS.md?](https://intraface.cc/glossary/agents-md/): AGENTS.md is a Markdown file you commit to a repository to tell AI coding agents how to work in it: setup and test commands, code style, conventions, things to avoid. It has no required format. Codex, Cursor, Zed, Copilot's coding agent, Claude Code and many others read it, so one file serves every agent on the team. - [What is an AI agent?](https://intraface.cc/glossary/ai-agent/): An AI agent is software that gives a language model a goal, a set of tools and a loop: the model picks an action, a tool carries it out, the result comes back, and the model decides again until the task is done or a limit stops it. A chatbot answers once; an agent keeps working. - [What is an AI artifact?](https://intraface.cc/glossary/ai-artifact/): An AI artifact is a self-contained piece of work an AI assistant makes for you and shows beside the conversation, not inside it: a document, a web page, a small app or a diagram. You iterate on it in place, and you can publish, share or export it on its own, so it outlives the chat that made it. - [What are AI citations?](https://intraface.cc/glossary/ai-citations/): AI citations are the links an answer engine attaches to the sentences it writes, pointing at the pages it drew on. ChatGPT, Perplexity and Google's AI Overviews all show them, each in its own way. Being cited is the AI-search equivalent of ranking: your page is named inside the answer instead of listed under it. - [What is AI code review?](https://intraface.cc/glossary/ai-code-review/): AI code review is a model reading a pull request's diff and the code around it, then leaving comments where it finds bugs, security problems or broken edge cases. Codex, GitHub Copilot, Cursor's Bugbot and Claude Code all offer one. The reviewer comments; a person still decides whether to merge. - [What are AI crawlers?](https://intraface.cc/glossary/ai-crawlers/): AI crawlers are the automated fetchers that AI companies run against the web: GPTBot and ClaudeBot gather training data, OAI-SearchBot, Claude-SearchBot and PerplexityBot build search indexes, and ChatGPT-User, Claude-User and Perplexity-User fetch a page when someone asks about it. Each announces itself in its user agent, and robots.txt rules are read per bot, though user-triggered fetchers may ignore them. - [What are AI Overviews?](https://intraface.cc/glossary/ai-overviews/): AI Overviews are the AI-written summaries Google shows at the top of some search results, with links to the pages the summary drew on. Google rolled them out to everyone in the US in May 2024. They appear only when Google's systems judge that a summary adds something to the classic results, so many searches never show one. - [What is AI pair programming?](https://intraface.cc/glossary/ai-pair-programming/): AI pair programming is writing code with an AI model beside you in the editor: it reads what you are working on and suggests the next line, a whole function or a fix, and you accept, edit or reject it. GitHub introduced Copilot as an AI pair programmer in 2021; agents that finish tasks alone are the next step. - [What is AI search optimization?](https://intraface.cc/glossary/ai-search-optimization/): AI search optimization (also called LLM SEO) is the work of making a website easy for AI search engines to crawl, read and quote: allow their crawlers in robots.txt, keep content as plain HTML text, open each page with a direct answer, mark it up with JSON-LD, and publish machine-readable indexes like a sitemap and an llms.txt file. - [What is answer engine optimization?](https://intraface.cc/glossary/answer-engine-optimization/): Answer engine optimization (AEO) is shaping a page so an answer engine, such as Google's AI Overviews, a featured snippet or a chat assistant, can lift your answer out and show it. In practice: one question per page, a short direct answer at the top, the detail underneath. The goal is to be the answer, not a link to one. - [What is an audit trail?](https://intraface.cc/glossary/audit-trail/): An audit trail is a chronological record of who did what and when, kept so you can reconstruct how something reached its current state. A version history where every version is kept with the name of whoever made it is an audit trail. The record is only useful if it cannot be edited quietly and nothing is skipped. - [What is a bearer token?](https://intraface.cc/glossary/bearer-token/): A bearer token is an access token that grants access to whoever presents it; possession is the only proof. RFC 6750 defines how to send one: in the Authorization header, after the word Bearer. API keys, OAuth access tokens and Intraface's ifc_ agent tokens all qualify, so anyone who copies one can act as you until it is revoked. - [What is a browser agent?](https://intraface.cc/glossary/browser-agent/): A browser agent is an AI agent that does tasks inside a web browser: it reads the page, clicks, scrolls, fills forms and moves between tabs, either as an extension in your own browser, like Claude in Chrome, or in a browser hosted for it. It acts on whatever a page shows it, so permissions and confirmations matter. - [What is ChatGPT Canvas?](https://intraface.cc/glossary/chatgpt-canvas/): ChatGPT Canvas is a workspace that opens beside the chat so you and ChatGPT edit one document or one code file in place, instead of pasting whole replies back and forth. You open it with /canvas or by asking to use canvas, highlight a passage to direct an edit, pick from a shortcut menu, and step back to earlier versions. - [What are Claude Code hooks?](https://intraface.cc/glossary/claude-code-hooks/): Claude Code hooks are commands, HTTP calls, MCP tools, prompts or subagents that Claude Code runs on its own at set points in a session: before a tool runs, after it finishes, when you submit a prompt, when the agent stops. A hook receives the event as JSON and can observe it, add context, or block it. - [What is Claude Code plan mode?](https://intraface.cc/glossary/claude-code-plan-mode/): Claude Code plan mode is a permission mode in which Claude reads files, runs commands to explore, and writes a plan, but does not edit your source. Edits stay blocked until you approve the plan. Turn it on with Shift+Tab, the /plan command or claude --permission-mode plan; approving the plan switches the session to a mode that can edit. - [What are Claude Code plugins?](https://intraface.cc/glossary/claude-code-plugins/): A Claude Code plugin is a directory of skills, subagents, hooks and MCP servers that Claude Code installs and loads as one unit. A small manifest at .claude-plugin/plugin.json gives it a name, which becomes the prefix on its skills. Most plugins come from a marketplace: a catalog file that lists plugins and says where to fetch each one. - [What are Claude Code slash commands?](https://intraface.cc/glossary/claude-code-slash-commands/): Claude Code slash commands are messages that start with a forward slash, such as /compact or /model, and run an action instead of going to Claude as plain text. Built-in commands execute fixed logic inside Claude Code. Custom commands are Markdown files in .claude/commands/ or skills in .claude/skills/, so /deploy expands into a prompt you wrote once. - [What is CLAUDE.md?](https://intraface.cc/glossary/claude-md/): CLAUDE.md is a Markdown file that Claude Code loads at the start of every session to give it standing instructions: build and test commands, conventions, project layout, rules to always follow. It can live at the project root, in your home directory, or in a managed location for an organization, and the files stack rather than replace each other. - [What is a cloud agent?](https://intraface.cc/glossary/cloud-agent/): A cloud agent is a coding agent that runs on a hosted machine instead of your laptop. You hand it a task from a browser, phone or terminal; it clones your repository into an isolated VM, works while you do something else, and pushes a branch or opens a pull request for you to review. - [What is a coding agent?](https://intraface.cc/glossary/coding-agent/): A coding agent is an AI agent whose tools work on a codebase: it searches and reads files, edits them, runs shell commands, tests and git, and reads the output to decide its next move. You describe the outcome, it does the work across as many files as needed, and you review the diff before anything ships. - [What is computer use?](https://intraface.cc/glossary/computer-use/): Computer use is a way for an AI model to operate a computer the way a person does: it looks at screenshots, then asks for mouse clicks, key presses and typed text. Anthropic's computer use tool defines those actions; your own code runs each one in a sandboxed desktop and sends back a fresh screenshot. - [What is the confused deputy problem?](https://intraface.cc/glossary/confused-deputy/): The confused deputy problem is when a program that holds authority is tricked into using it for someone who should not have it. The deputy is honest but confused: it cannot tell whose request it is serving. In MCP, the classic case is a proxy server that signs in to a third-party API with one shared client ID. - [What is content-addressable storage?](https://intraface.cc/glossary/content-addressable-storage/): Content-addressable storage is a way of storing data where the key is a hash of the content itself, not a path or a name you choose. Store the same bytes twice and you get the same key, so duplicates collapse into one copy, and anyone holding the key can check that what they fetched is what they asked for. - [What is context engineering?](https://intraface.cc/glossary/context-engineering/): Context engineering is the practice of deciding what goes into a model's context window at every step of an agent's run: the system prompt, tool definitions, retrieved documents, message history and tool results. The aim is the smallest set of high-signal tokens that makes the right outcome likely, because attention is finite and more context is not automatically better. - [What is context rot?](https://intraface.cc/glossary/context-rot/): Context rot is the tendency of language models to answer less reliably as their input grows, even when the task does not change. A fact the model finds easily in a short prompt gets missed once it sits among tens of thousands of tokens. The term comes from a 2025 Chroma report that measured the effect across 18 models. - [What is a context window?](https://intraface.cc/glossary/context-window/): A context window is the total amount of text, measured in tokens, that a language model can take into account while producing a reply, including the reply itself. The system prompt, every message so far, tool definitions, tool results and the model's own output all count toward it. When it is full, something has to be dropped or summarised. - [What are Copilot instructions?](https://intraface.cc/glossary/copilot-instructions/): Copilot instructions are Markdown files in a repository that GitHub Copilot adds to every request it handles there. The repository-wide file is .github/copilot-instructions.md; path-specific files end in .instructions.md and carry an applyTo glob. Copilot Chat, the cloud agent and code review all read them, and a reply lists the file among its references. - [What is a CRDT?](https://intraface.cc/glossary/crdt/): A CRDT (conflict-free replicated data type) is a data structure that several copies can change independently, offline or at the same moment, and that merges those changes by fixed mathematical rules so every copy ends up identical. No server decides the order and nobody resolves a conflict by hand. Counters, sets, maps and text sequences all have CRDT forms. - [What are Cursor rules?](https://intraface.cc/glossary/cursor-rules/): Cursor rules are standing instructions for Cursor's Agent, stored as .mdc files in your project's .cursor/rules folder and checked into git. Each rule says when it applies: always, for files matching a glob, when the Agent judges it relevant, or only when you @mention it. User rules add personal preferences across every project. - [What are design tokens?](https://intraface.cc/glossary/design-tokens/): Design tokens are the named values of a design: a color called brand.primary, a spacing step, a font size. Instead of hard-coding #1A73E8 in ten places, you give the value a name once and everything refers to the name. The W3C Design Tokens Community Group defines a JSON format so design tools and code read the same file. - [What is the device code flow?](https://intraface.cc/glossary/device-code-flow/): The device code flow is the OAuth grant from RFC 8628 for machines that cannot open a browser or take typed input: servers, containers, TVs. The device shows a short code and a link; you open the link on any other device, sign in, and type the code. Meanwhile the device polls the token endpoint until the token arrives. - [What is dynamic client registration?](https://intraface.cc/glossary/dynamic-client-registration/): Dynamic client registration is an OAuth protocol, RFC 7591, that lets an app introduce itself to an authorization server automatically. The app posts its name, redirect URIs and grant types to a registration endpoint and receives a client_id, with no portal and no form. MCP clients use it to sign in to servers they have never met. - [What is function calling?](https://intraface.cc/glossary/function-calling/): Function calling, also called tool calling, is how a language model asks your code to do something. You describe each function with a name, a description and a JSON Schema for its arguments. The model replies with a structured call instead of prose, your program runs it and sends the result back, and the model continues with that information. - [What is Gemini Canvas?](https://intraface.cc/glossary/gemini-canvas/): Gemini Canvas is a workspace inside Google's Gemini app where you and Gemini work on one document, slide deck, app or piece of code side by side with the chat. You edit it directly or ask for changes, move between saved versions, preview code, and export to Google Docs, Slides or Colab or share a link. - [What is GEMINI.md?](https://intraface.cc/glossary/gemini-md/): GEMINI.md is the context file Gemini CLI reads to learn how you want it to work: coding style, project facts, standing instructions. The CLI looks for one in ~/.gemini for every project, in the project directory and its parents, and in directories its tools touch. It concatenates all of them and sends the result with each prompt. - [What is generative engine optimization?](https://intraface.cc/glossary/generative-engine-optimization/): Generative engine optimization (GEO) is improving how often, and how prominently, your content appears in answers that a generative engine writes: ChatGPT, Perplexity, Google's AI Mode. The term comes from a 2023 paper by Aggarwal and others, which found that adding citations, quotations and statistics raised visibility by up to 40 percent while keyword stuffing did little or nothing. - [What is human in the loop?](https://intraface.cc/glossary/human-in-the-loop/): Human in the loop means a person stays part of an automated process: they approve, correct or reject what the system proposes before it takes effect. For AI agents, it is the permission prompt before a command runs or the review before a publish. The point is to put a person where a mistake would be expensive. - [What is JSON-RPC?](https://intraface.cc/glossary/json-rpc/): JSON-RPC is a lightweight remote procedure call protocol that encodes every message as JSON: a request names a method and carries params and an id, the response echoes that id with a result or an error, and a notification has no id and gets no reply. Version 2.0, from 2010, is the one the Model Context Protocol is built on. - [What is a living document?](https://intraface.cc/glossary/living-document/): A living document is a document that is edited and updated for as long as it is in use, instead of being finished and filed. A wiki page, a team runbook or a shared board is one; a signed contract is not. The trade-off is that there is no single final version, so you need history to see what changed. - [What is llms.txt?](https://intraface.cc/glossary/llms-txt/): llms.txt is a proposed plain-text file, served at /llms.txt, that gives AI agents a short Markdown guide to a website: a title, a one-paragraph summary, and lists of links with notes. Jeremy Howard proposed it in September 2024. Thousands of sites publish one, but no major search or answer engine has documented reading the file. - [What is a local MCP server?](https://intraface.cc/glossary/local-mcp-server/): A local MCP server is a Model Context Protocol server that your AI client launches as a program on your own computer, usually over the stdio transport: the client writes JSON-RPC messages to the process's standard input and reads replies from its standard output. Because it runs where you do, it can reach your files, shell and local tools. - [What does machine-readable mean?](https://intraface.cc/glossary/machine-readable/): Machine-readable means a computer can read and process the data without a person interpreting it first and without losing its meaning. For a web page that means more than text in a browser: headings in real HTML, structured data such as JSON-LD, a sitemap, and an llms.txt index that an AI crawler or agent can parse directly. - [What is MCP?](https://intraface.cc/glossary/mcp/): MCP stands for Model Context Protocol. It is an open protocol that gives AI applications one standard way to connect a language model to outside data and tools. An app such as a coding agent talks JSON-RPC to MCP servers, which expose tools, resources and prompts. Build a server once and every MCP app can use it. - [What are MCP Apps?](https://intraface.cc/glossary/mcp-apps/): MCP Apps is an official extension to the Model Context Protocol that lets an MCP server return an interactive HTML interface, such as a chart, form or viewer, which the chat host renders inline in a sandboxed iframe. The app talks to the host over JSON-RPC via postMessage and can call the server's tools itself. - [What is an MCP client?](https://intraface.cc/glossary/mcp-client/): An MCP client is the component inside an AI application that talks to one MCP server. The host app creates a client per server; the client sends JSON-RPC requests, attaches the protocol version and its capabilities to each, routes results back to the host and keeps that server separate from the others. - [What is an MCP connector?](https://intraface.cc/glossary/mcp-connector/): An MCP connector is the name Claude and similar chat apps give a remote MCP server attached to your account. You add it from the Connectors directory or by pasting a server URL, sign in once, and Claude can then read from that service and act in it, in claude.ai, the desktop and mobile apps, Claude Code and Cowork. - [What is MCP elicitation?](https://intraface.cc/glossary/mcp-elicitation/): MCP elicitation is how an MCP server asks the person for more information in the middle of a request, through the client. In form mode the server sends a small JSON schema and the client renders a form; in URL mode it sends a link the person opens in a browser, for secrets the client must never see. - [What is an MCP gateway?](https://intraface.cc/glossary/mcp-gateway/): An MCP gateway is a server that sits between your agents and many MCP servers. Agents connect to one address and one sign-in; the gateway forwards each call to the right server behind it, adds its own credentials, and can log, filter or rate-limit on the way. The MCP spec covers this role under the name MCP proxy server. - [What is an MCP host?](https://intraface.cc/glossary/mcp-host/): An MCP host is the application that runs the Model Context Protocol on the user's side: a coding agent, an IDE or a chat app. It creates one MCP client per server, holds the conversation and the model, decides which tools the model sees, and asks you for consent before data leaves or a tool runs. - [What is the MCP Inspector?](https://intraface.cc/glossary/mcp-inspector/): The MCP Inspector is the Model Context Protocol project's developer tool for testing MCP servers without an AI model in the loop. One npx command opens a local web UI that connects to your server over stdio or HTTP, lists its tools, resources and prompts, calls them with arguments you type, and shows the raw JSON-RPC messages. - [What is MCP OAuth?](https://intraface.cc/glossary/mcp-oauth/): MCP OAuth is the sign-in flow the Model Context Protocol defines for remote servers. The agent's client discovers the server's authorization server from metadata, sends you to a browser to approve, and gets an access token back using OAuth 2.1 with PKCE. You never copy an API key, and you can revoke the token later. - [What are MCP prompts?](https://intraface.cc/glossary/mcp-prompts/): MCP prompts are reusable message templates an MCP server offers to the client. The person picks one, often as a slash command, fills in its arguments, and the server returns ready-made messages for the model, with text, images, audio or linked resources inside. The server writes the words; the user decides when they are used. - [What are MCP resources?](https://intraface.cc/glossary/mcp-resources/): MCP resources are pieces of data an MCP server offers to the client as context for the model: a file, a database schema, a record, each identified by a URI. The client lists them, reads the ones it wants, and decides what reaches the model. Unlike tools, the model does not call them; the application does. - [What is MCP sampling?](https://intraface.cc/glossary/mcp-sampling/): MCP sampling lets an MCP server ask the client to run a language model on its behalf, using the client's own model access and keys, with a person able to review and refuse each request. As of the 2026-07-28 revision the feature is deprecated: new servers should call a model provider's API directly instead. - [What is MCP security?](https://intraface.cc/glossary/mcp-security/): MCP security is the set of risks and controls around letting an AI agent talk to MCP servers: who the server is, what its tools may do, which token it accepts, and whether content coming back can steer the model. The spec's security best practices name the attacks and the fixes: confused deputies, token passthrough, hijacked handles and more. - [What is an MCP server?](https://intraface.cc/glossary/mcp-server/): An MCP server is a program that gives AI applications access to one system through the Model Context Protocol. It exposes tools the model can call, resources the app can read and prompts a person can pick, and answers JSON-RPC requests from an MCP client. It can run as a local process or as a service at a URL. - [What are MCP tools?](https://intraface.cc/glossary/mcp-tools/): MCP tools are functions an MCP server exposes for a language model to call. Each tool has a name, a description and a JSON Schema for its arguments. The client lists them with tools/list, the model picks one, and tools/call runs it and returns content. Tools are the way an agent acts, not just reads. - [MCP vs A2A: what's the difference?](https://intraface.cc/glossary/mcp-vs-a2a/): MCP (Model Context Protocol) standardises how one AI agent reaches its tools, data and prompts. A2A (Agent2Agent) standardises how independent agents find each other, hand over tasks and return results. The A2A project describes them as complementary: MCP is vertical, deepening a single agent, and A2A is horizontal, linking agents across teams and vendors. - [MCP vs API: what's the difference?](https://intraface.cc/glossary/mcp-vs-api/): MCP and an API solve different problems. An API is a fixed contract your code calls; you read the docs and write the integration. MCP is a protocol that lets an AI model discover a service's tools at run time and call them in one standard shape, so every MCP client can use the service without custom code. - [MCP vs RAG: what's the difference?](https://intraface.cc/glossary/mcp-vs-rag/): RAG and MCP both get outside knowledge to a model, at different moments. RAG (retrieval-augmented generation) searches an index, usually of embedded text, and pastes the best passages into the prompt before generation. MCP is a protocol that lets the model call tools and read resources during its run, so it can fetch live data and take actions. - [What is a merge conflict?](https://intraface.cc/glossary/merge-conflict/): A merge conflict happens when two changes to the same file touch the same lines in different ways and a tool cannot combine them automatically. Git stops, marks the disputed region with conflict markers, and waits for a person to pick one side, or write a mix of both, before the merge can finish. - [What is a multi-agent system?](https://intraface.cc/glossary/multi-agent-system/): A multi-agent system is a setup in which several AI agents work on one task instead of a single agent doing everything. Most follow an orchestrator-worker pattern: a lead agent plans, spawns subagents that run in parallel with their own context windows, and merges what they return. It wins on breadth and parallel search, and it costs far more tokens. - [What is OAuth 2.1?](https://intraface.cc/glossary/oauth-2-1/): OAuth 2.1 is the in-progress revision of the OAuth 2.0 authorization framework. It removes the implicit and password grants, makes PKCE mandatory for the authorization code flow, requires exact redirect URI matching, and bans access tokens in URL query strings. It is the version the MCP authorization spec builds on, so coding agents inherit its rules. - [What is operational transformation?](https://intraface.cc/glossary/operational-transformation/): Operational transformation (OT) is a technique for letting several people edit one document at the same time. Each edit is an operation with a position, like insert this text at character 9. When an edit made against an older copy arrives, OT transforms it, shifting its position by the edits it crossed, so every copy ends up identical. - [What is optimistic concurrency control?](https://intraface.cc/glossary/optimistic-concurrency-control/): Optimistic concurrency control lets many writers work on the same record without locking it. Each one reads the current version number, makes its change, and asks the store to write it only if the version is still the same. If someone else wrote first, the write is refused and the writer re-reads and retries. - [What is PKCE?](https://intraface.cc/glossary/pkce/): PKCE, Proof Key for Code Exchange, is an OAuth extension from RFC 7636 that protects the authorization code flow for apps that cannot keep a secret. The client invents a random verifier, sends its SHA-256 hash with the sign-in request, and later presents the verifier when it trades the code for a token. A stolen code alone buys nothing. - [What is programmatic SEO?](https://intraface.cc/glossary/programmatic-seo/): Programmatic SEO is building many pages from a dataset and a shared template, one page per entity: a term, a tool, a city. Done well, every page has unique, checked content and a real reader. Done badly, it is thousands of near-identical pages that Google's spam policies call scaled content abuse. - [What is prompt caching?](https://intraface.cc/glossary/prompt-caching/): Prompt caching is an API feature that stores the processed form of a prompt's opening section so later requests beginning with the same tokens can skip that work. Cached input is billed at a fraction of the normal rate and comes back faster. It helps only when the prefix is identical, so stable content goes first and changing content last. - [What is prompt injection?](https://intraface.cc/glossary/prompt-injection/): Prompt injection is an attack where text that a language model reads is written to change what the model does, overriding the instructions it was given. The text can come from the user or hide in a web page, file or tool result the model processes. It works because models treat instructions and data as one stream. - [What is a ReAct agent?](https://intraface.cc/glossary/react-agent/): A ReAct agent is a language model prompted to alternate reasoning and acting. It writes a short thought about what to do next, takes an action such as a search, reads the observation, and thinks again until it can answer. The pattern comes from the 2022 ReAct paper by Yao et al.; most tool-using agents descend from it. - [What is a rebase?](https://intraface.cc/glossary/rebase/): A rebase takes a change you made against an older version and replays it on top of the newest one, as if you had started there. In git, git rebase moves a branch's commits onto another branch's tip. On a shared board, an agent whose publish is refused as needs_rebase pulls the latest version and redoes its edit. - [What is a remote MCP server?](https://intraface.cc/glossary/remote-mcp-server/): A remote MCP server is a Model Context Protocol server your AI agent reaches over the internet at a URL, instead of starting it as a program on your own machine. It speaks the Streamable HTTP transport, and most ask you to sign in with OAuth the first time, so nobody has to copy an API key. - [What is semantic HTML?](https://intraface.cc/glossary/semantic-html/): Semantic HTML uses elements for what content is, not how it should look: main, article, nav, h1 to h6, ul, table, instead of a div with a class. The browser draws the same pixels, but screen readers, search crawlers and AI agents get the structure, so they can find the main content, the headings and the section to edit. - [What is a shared workspace?](https://intraface.cc/glossary/shared-workspace/): A shared workspace is one place where several people see and change the same things, with a record of who did what. It began as shared documents and channels. The newer meaning adds people's AI agents as participants: each agent pulls the shared thing, edits it, and puts a new version back where everyone can see it. - [What is a single source of truth?](https://intraface.cc/glossary/single-source-of-truth/): A single source of truth is the one place where a piece of information is kept and edited, so every other copy, view or report is derived from it rather than maintained on its own. When the fact changes, you change it there once, and nothing else can quietly disagree with it. - [What is spec-driven development?](https://intraface.cc/glossary/spec-driven-development/): Spec-driven development is a way of working with coding agents where you write down what to build and why before any code exists. The agent turns that specification into a technical plan, then a list of tasks, then an implementation it checks against the spec. The document, not the chat, is the source of truth for the feature. - [What is Streamable HTTP in MCP?](https://intraface.cc/glossary/streamable-http/): Streamable HTTP is the MCP transport for servers reached over the network. The client sends every JSON-RPC message as an HTTP POST to one endpoint, such as /mcp, and the server answers with either a JSON object or a server-sent events stream for that request. It replaced the older HTTP+SSE transport in the 2025-03-26 revision. - [What is structured data?](https://intraface.cc/glossary/structured-data/): Structured data is a block of typed facts about a page, in the schema.org vocabulary, so machines can read it without parsing the prose. Google recommends JSON-LD, a script tag holding the facts as JSON. It must match the visible page. Search engines use it for rich results and to classify the page; other crawlers can lift the same facts. - [What is a subagent?](https://intraface.cc/glossary/subagents/): A subagent is a separate AI agent that a coding agent starts to handle one task, such as searching a codebase or reviewing a diff. It runs with its own context window, its own system prompt and often a narrower set of tools, then returns a summary. The main agent keeps its context for decisions instead of raw output. - [What is a system prompt?](https://intraface.cc/glossary/system-prompt/): A system prompt is the instruction text an application sends to a model before the conversation: who the model is, what it may do, what it knows about the setting. In the Claude API it is the top-level system parameter; in OpenAI's Responses API, the instructions parameter or a developer message. Models rank it above user messages. - [What is a three-way merge?](https://intraface.cc/glossary/three-way-merge/): A three-way merge combines two edited versions of a file by also looking at the version they both started from, the base. For each region it asks which side changed it: if only one did, that change wins; if neither, the base stays; if both changed it differently, it is a conflict left for a person. - [What is topical authority?](https://intraface.cc/glossary/topical-authority/): Topical authority is a site's standing as a thorough, reliable source on one subject, built by covering that subject in depth rather than touching many. In practice it means a hub page plus a cluster of specific, interlinked pages. Google's guidance does not define the term, but it asks whether a site has a primary purpose or focus. - [What is version history?](https://intraface.cc/glossary/version-history/): Version history is the record of every saved state of a document or file: what changed, who changed it and when. Instead of overwriting the old copy, each save adds a new version, so you can compare two points in time, see who did what, and restore an earlier version if a change went wrong. - [What is vibe coding?](https://intraface.cc/glossary/vibe-coding/): Vibe coding is building software by telling an AI model what you want and accepting the code it writes without reading it. Andrej Karpathy coined the term in February 2025 for throwaway weekend projects. It is fast for prototypes and personal tools, and risky for anything other people depend on, because nobody has reviewed what shipped. - [What are Windsurf rules?](https://intraface.cc/glossary/windsurf-rules/): Windsurf rules are Markdown instructions the Cascade agent follows in every workspace or in one project. Global rules live in one file under ~/.codeium/windsurf/memories; workspace rules are one file per rule in the project, each with a trigger: always on, glob, model decision or manual. Cascade also writes its own memories, stored locally, not in the repo. - [What is YOLO mode?](https://intraface.cc/glossary/yolo-mode/): YOLO mode is the setting that lets a coding agent run every tool call, file edit and shell command without asking you first. Gemini CLI names it --yolo, Cursor calls it Run Everything, Claude Code calls it bypassPermissions. It trades every safety prompt for speed, so vendors tell you to use it only inside a container or VM. - [What is zero-click search?](https://intraface.cc/glossary/zero-click-search/): A zero-click search is a search that ends without the person clicking through to any website. The results page answers the question, with a featured snippet, a knowledge panel, a map, or an AI Overview. Pew Research Center found in 2025 that people clicked a result on 8% of result pages with an AI summary, against 15% without one. ## Intraface compared - [Intraface vs AgentGrid](https://intraface.cc/vs/agentgrid/): AgentGrid and Intraface both let agents publish to a shared page and both catch edits made on an old version. AgentGrid rejects any stale edit with REVISION_CONFLICT and gives you git branches to work in. Intraface lands stale publishes that touch different files and only bounces the ones that changed the same file. - [Intraface vs here.now](https://intraface.cc/vs/here-now/): Use here.now when one agent needs files online fast: no account, custom domains, big storage, cheap plans. Use Intraface when several people's agents keep editing the same page. here.now rejects a stale update or lets you overwrite it; Intraface queues publishes and merges edits to different files onto the latest version. - [Intraface vs OpenAgents](https://intraface.cc/vs/openagents/): OpenAgents and Intraface solve different halves of the same job. OpenAgents (openagents.org) is an open-source workroom where Claude Code, Codex, Cursor and other agents chat in threads, share files and a live browser. Intraface is a shared HTML page those agents publish to, with versions, merges and comments. Most teams would use both. - [Intraface vs spacesheep](https://intraface.cc/vs/spacesheep/): spacesheep is the closest tool to Intraface: agents publish a page over MCP or a CLI, people comment, and several agents can work on it. spacesheep rejects any publish made on an old base_sha and gives agents a Discussion thread to coordinate. Intraface lands stale publishes to different files and bounces only same-file clashes. ## Alternatives - [CodePen alternatives: 5 tools for sharing HTML your AI made](https://intraface.cc/alternatives/codepen/): If your AI writes the HTML and you only need it online, CodePen is the wrong shape: an agent can't publish a Pen without a person saving it. here.now publishes over an API. JSFiddle and StackBlitz stay closest to CodePen's editor. Replit hosts apps its agent builds. Intraface keeps one page that a team's agents edit. - [GitHub Pages alternatives: 6 tools for sharing HTML your AI made](https://intraface.cc/alternatives/github-pages/): Cloudflare Pages and Netlify are the closest swaps: free static hosting, git or CLI deploys, and custom domains. GitLab Pages adds members-only sites on its free tier. Vercel and AgentGrid give agents an MCP server. Intraface is for a page several people's agents keep editing, where publishes queue and merge without a pull request. - [Netlify Drop alternatives: 6 tools for sharing HTML your AI made](https://intraface.cc/alternatives/netlify-drop/): Vercel Drop is the nearest copy, and static sites now work there without an account too. Cloudflare Pages Direct Upload takes bigger folders. AgentGrid lets an agent publish with no signup. Surge and tiiny.host suit repeat uploads. Intraface is for a page several people's agents keep editing after the first drop. - [tiiny.host alternatives: 5 tools for sharing HTML your AI made](https://intraface.cc/alternatives/tiiny-host/): For one finished HTML file, Netlify Drop or here.now get you a link with no account, and Surge does it from the command line. spacesheep adds comments and an MCP server for your agent. Intraface fits when several people's agents keep editing the same page: publishes queue, and edits to different files merge. ## Links - [Home](https://intraface.cc/) - [Pricing](https://intraface.cc/pricing/): pricing isn't published; contact us - [About](https://intraface.cc/about/): what Intraface is, who builds it and why - [Docs](https://intraface.cc/docs/) - [Blog](https://intraface.cc/blogs/) - [CLI on npm](https://www.npmjs.com/package/intraface) - [Start for free](https://app.intraface.cc/sign-up): create an account, connect your coding agent, and make your first board