OpenTide
The agent-native web framework.
During development, your app runs as a long-lived process inside the OpenTide kernel. Agents don't read and rewrite files. They inspect and change the running app through MCP tools that encode the kernel's rules, so every change follows the same discipline, whichever model makes it.
01Gated access
Your code lives as a semantic graph, exposed to agents through MCP tools. Agents query exactly the nodes they need, and the OpenTide kernel decides what a valid change looks like, not the prompt.
02The running app is the source
No code files to generate or keep in sync during development. The live process is the canonical artifact, persisted with state snapshots. When you ship, export it as a Deno app, a Node app, a standalone binary or a Docker image.
03Typed mutations
The graph is typed. Every edit lands as a serializable mutation to it, like AddNode or ReplaceBody, written to an append-only log. Because mutations are plain data, you can inspect, diff and replay them, and every entity carries its own revision number.
04Verified before commit
Each mutation is checked for well-formedness, graph consistency, effect constraints and contracts, then forked, verified and committed atomically. The kernel mints tamper-resistant evidence for every check, and a change with stale or missing evidence can’t close.
05History you can roll back
The log event-sources how the app evolved. Inspect any change, see why it was made, and roll it back. Changes are grouped into changesets tied to the agent turn that made them, and snapshots restore the whole app to any saved point.
06Token-efficient
Agents work on precise app entities instead of reading whole codebases, so the context window goes to the task. Tools return structured answers, like a route’s handler, a table’s columns or a function’s callers, instead of raw file dumps.
07Bring your own agent
OpenTide runs as an MCP server. Point Claude Code, Codex or Cursor at your project over stdio or HTTP, and they get the same governed tools as the IDE.
08Live changes, no restarts
Agent edits land in the running kernel, get recompiled and re-served immediately. You iterate on the running app, not a source tree.
09Headless and model-neutral
opentide serve, mcp, scaffold, build and export from the terminal. The core runs without an LLM key and without a login.
Every change earns its commit
A mutation only lands if it passes every gate. The kernel's apply, commit and rollback semantics are formally specified.
6 · Atomic commit. Only after every gate passes is the mutation appended to the log and swapped into the live app in one step. If anything fails, nothing changes.
Tide
The IDE reinvented for AI.
Chat with an agent on one side, your running app on the other. Plan with acceptance criteria, build against the live app, and see every change verified before it counts as done. You direct the work. The agent writes the code.
>_Agent-first
Every change comes with its why and its approach, so you can review intent as well as the diff.
>_The live app, in view
Preview the running app next to its request logs, and explore a live call graph of what is actually running.
>_Verification built in
Changesets are checked against their acceptance criteria before they close. Readiness blockers tell you what's missing.
>_Tests and audits
The test suite runs inside the kernel. Audits cover accessibility, code quality, performance, security and SEO.
>_A model for each job
Pick different models for the agent, planning, import and verification, and keep an eye on tokens and cost per session.
>_Docs, search and Git
Generated documentation next to the source, search across everything, then commit and push when you're ready.
The tide is coming in.
OpenTide and Tide are in active development. Leave your email and we'll let you know when the first release is out.
One email when we launch. No spam.