early access
Project cycles for teams where development never stops
Build and maintain with confidence by orchestrating task agents through repeatable cycles. vem revalidates completed work, reduces accidental breaking changes, and helps ensure features keep working as intended.
{
"cycle": "revalidation-pass",
"snapshot_hash": "f74b...",
"git_hash": "ad71...",
"status": "verified"
}Cloud DB source of truth
Shared state lives in the cloud, not in git-tracked `.vem` files.
Git-backed verification
Each snapshot carries `git_hash` + `snapshot_hash` for auditability.
Fast team retrieval
Search and analytics run against one canonical memory stream.
Secure by default
Tenant isolation and traceable timeline for memory updates.
Shared memory
Shared memory for every AI agent in your repo
Keep `.vem/` as a local workspace cache and sync canonical memory to the cloud. Tasks, decisions, and snapshots become searchable, auditable, and available to every agent and teammate.
Web execution
Operate repos from the web without losing execution boundaries.
vem splits online execution into two clear paths: paired local workspace commands and isolated sandbox task agents.
Workspace terminal
Web commands executed by a paired vem runner
- Start a runner on any machine:
vem runner --agent copilot - The runner reports its online status, current branch, and worktree state back to the web UI in real time.
- Submit normal shell commands from the browser and see streamed output — ideal for
git status, build checks, or diagnostics.
Cloud task execution
Task agents run in isolated sandbox workspaces
- Launch an agent directly from a task page — no local runner required.
- The sandbox clones your repo from GitHub into an isolated environment before execution.
- Successful runs push a task branch and open a pull request automatically.
Project Cycles
Development and maintenance never stop. Revalidation should not stop either.
Project cycles keep delivery honest: each pass rechecks prior work, orchestrates task agents around scoped changes, and reduces the risk of accidental regressions before merge.
Revalidate completed work
Run the same standards against existing features so drift and regressions are surfaced early.
Orchestrate task agents
Coordinate focused agents per task so implementation, checks, and handoffs stay explicit and traceable.
Confirm intended behavior
Use cycle feedback to verify features still behave as intended while reducing risky, accidental breakage.
How It Works
Three steps from context to verified memory.
The workflow is built for high-velocity teams: capture locally, sync immediately, verify automatically with git events.
Capture locally
Agents and developers update `.vem` as local workspace memory.
Push to cloud
`vem push` writes pending snapshots to the shared memory service.
Verify on git push
Webhooks match provenance metadata and finalize snapshots as verified.
Storage Model
Keep local memory lightweight. Keep shared memory canonical.
Local files help the current workspace. Cloud records keep the durable team timeline. This separation removes git noise and keeps collaboration consistent across agents.
Default behavior
`.vem/` is gitignored and used as a local cache for active work.
Cloud state powers search, analytics, and cross-agent handoffs.
Git metadata verifies integrity without committing workspace memory.
Local workspace cache (`.vem/`)
Current context and active task objects
Fast local edits by CLI and MCP tools
Not committed to git
Canonical cloud memory
Pending and verified snapshot lifecycle
Searchable tasks, decisions, and context history
Shared state across humans and agents
Why Teams Choose vem
Memory you can trust under real delivery pressure.
vem aligns multi-agent workflows with the same source of truth, so handoffs are faster and regressions are easier to prevent.
Included in the platform
MCP tools + CLI parity
Task + decision tracking
Snapshot verification lifecycle
Cloud search + analytics
Workspace terminal + runner
Sandbox task runs + PR creation
Agent + human parity
MCP tools and CLI operate on the same shared memory state.
Clear orchestration
Track intent, evidence, and handoffs without prompt archaeology.
Git-verified timeline
Every snapshot is tied to deterministic provenance metadata.
Fast retrieval
Find relevant decisions and tasks in seconds across project history.
Workspace terminal
Run project commands from the web through a paired local runner.
Task to PR flow
Trigger isolated task agents online and turn successful runs into branches and pull requests.
Cloud indexing
Query and analyze canonical memory across repos and teams.
Secure by default
Tenant isolation and auditable trails for critical workflows.
Start Building
Move from fragile prompts to durable memory.
Give your team one place for verifiable context, shared history, and fast retrieval across every coding session.