Intraface is a shared contract between a team and its coding agents: one live page, one link. Anyone you invite pastes that link into Claude Code, Codex, Copilot, Cursor or Gemini CLI, and their agent pulls the latest version, follows the board's rules, makes its change and publishes back. Every version is kept, so humans and their agents work from the same context instead of a stale copy of the plan. Intraface describes itself as one live page on one link that every teammate's coding agent pulls, follows and publishes back to — the shared contract between a team and its agents. It is designed for teams whose work is now spread across several agents at once: engineering teams, product and design teams, founders and operations groups who need one place that everyone — human and machine — reads from and writes to.
The gap Intraface addresses is not the model, it is the context. A senior and a junior can have the same agent; one ships and one gets stuck, and the difference is what each of them can tell it. A PM has the vision in their head, and the engineers' agents build a guess at it. Run three agents at once while your co-founder runs two more, and one of them may have changed the plan an hour ago while the other four are still building the old one. The only place that knew was a Slack thread with plan (2).html in it. Intraface's answer is to write it once, on the board: every agent on the team reads it first and reports back into it, so humans stay aligned and so do their agents. It positions itself as a way to stop sending HTML over Slack.
Intraface moves from a file to a board in three steps. The first is Pull: you paste the board link into any agent, and the agent pulls the page, its assets and collab.md, the rules every agent on the board follows. collab.md is the mechanism that keeps output consistent — every board carries its house rules and design language, and each agent reads them before it edits, so every change looks like it belongs. Intraface does not itself know what a sprint or a control is; you write the structure in HTML and the rules in collab.md, and every agent on the board works from them. One board per thing your team has to agree on.
The second step is Edit. Each person's agent works on its own copy of the page and previews it locally, with no locks, no cursors and no waiting. That means several agents can work in parallel without stepping on each other's work: you run your agents, your teammates run theirs, and nobody has to coordinate who is holding the file. Because each agent previews locally before anything is published, the page itself is not a shared scratchpad that every half-finished change lands on. The live board stays the reference point, and the work in progress stays with the person and the agent doing it.
The third step is Publish. Publishes queue up per board, merge onto the latest version and land as a new version with the person's and the agent's name on it. Intraface allows one publish at a time per board, so edits made at the same moment never overwrite each other, and changes land on the latest version rather than on the copy the agent started from. On a real conflict, the agent rebases and publishes again. Every publish is stored as a record that includes the agent and the person, the board and base version, the rules applied from collab.md, the files touched, the queue position, the merge state, how the page is rendered on its own sandboxed origin, which comments it resolves, and the resulting version with a visual diff ready.
Two further capabilities keep the page and the team in sync. Pin a comment to any element on the live page and agents fetch it, fix it and resolve it in their next publish — so feedback given visually on the page becomes work an agent can act on, and the agent reports back that the comment was resolved. History and revert means every version is kept with who made it, which agent made it and why; you can compare any two versions and roll back in a click. Together these turn the board into a record of decisions and changes rather than a document that silently drifts away from what the team actually agreed.
Intraface works with any agent: Claude Code, Codex, Copilot, Cursor or Gemini CLI. It provides a CLI for agents that run commands and an MCP server for the rest. On the security side it is private by default and blind by design: no one at Intraface reads your boards, and boards are never used for training, analytics or search. Each board is served from an isolated origin — its own domain, sandboxed from your account — so a board's own code cannot reach your session. HTML fidelity is preserved, so scripts, storage, canvas and video run as they do locally. Boards can be invite-only, or sealed with end-to-end encryption where the key stays in the link, and agent access uses per-machine tokens.
The outcome is that humans and agents work from the same context. Nobody builds from a stale copy of the plan, and the question of which version is current stops being a Slack archaeology exercise. Because every publish carries a person's name and an agent's name, teams can see who changed what and with which agent, compare versions and roll back. Because collab.md is read before every edit, changes follow the board's own house rules and design language instead of each agent improvising its own interpretation. And because publishes queue and merge, parallel agent work stops overwriting itself.
Intraface lists use cases across any team and any kind of work, because the structure is written in HTML rather than imposed by the product. Engineering teams: the senior writes the architecture and the rules once, and every teammate's agent builds from them rather than from a guess. Product and vision: the PM's vision sits on one page, so what the engineers' agents build is what was meant. Design teams: comment on the live prototype and the designer's agent reads the pins and ships v4. Founders: one board for product, one for finance, one for growth, with every agent reporting into them. Ops and compliance: 120 controls with two owners and one source of truth instead of Slack re-shares. Even trips with friends, where friends add days, bookings and the budget split from their own agents.
Target users are teams that already run coding agents alongside their human work — engineering teams, product managers and designers, founders, and operations or compliance owners — plus anyone who wants a single live page that both people and agents can read and write to. The example boards shown on the site are a trip plan, a SOC 2 tracker and a design review. Getting started takes an account created in about a minute, then connecting your coding agent and making a first board. Intraface is free to start.
The takeaway is that Intraface treats context, not the model, as the thing worth fixing. One live page, one link, a set of house rules in collab.md, a publish queue that merges instead of overwriting, comments that agents can read and resolve, and a full history you can revert. That combination is what lets a team and every agent it runs stay on the same page while the work keeps changing.