Overview

Rosetta is a consulting control plane for AI coding agents. It consults them with versioned, expert-prepared instructions so every agent follows your organization's rules, conventions, and knowledge — from day one.

Architecture

When you type a request in your IDE, the agent loads context from Rosetta first — then follows your organization's proven workflows. Source code never leaves your machine.

Your IDE
Cursor · Claude Code · VS Code · JetBrains · Codex
Rosetta
Rosetta MCP
VFS · Bundler · Tags · Context headers
Rosetta Server
RAGFlow · parse · chunk · embed · retrieve

Session Lifecycle

Bootstrap → Classify → Load → Execute. Guardrails and project context load automatically before the agent acts.

Progressive Disclosure

Instructions load on demand. The agent gets only what it needs for your specific request — context stays focused, responses stay precise.

Three-Layer Instructions

Core · Organization · Project — merged at runtime into a single resource path. Published via Rosetta CLI from your Instructions Repo.

Design Principles

Agent-agnostic

Click to explore

Works across Cursor, Claude Code, VS Code, Windsurf, JetBrains, GitHub Copilot, Codex, and any MCP-compatible IDE. Adopts agent-specific features where available, simulates them where not.

Progressive disclosure

Click to explore

Instructions load in stages — bootstrap, classification, workflow-specific. The agent gets only what it needs for the current task. Prevents context overflow.

Classification-first

Click to explore

Every request is auto-classified into a workflow type before any work begins. Classification drives which instructions, skills, and rules load.

Release-based versioning

Click to explore

Instructions organized by release (r1, r2, r3). New instructions develop without breaking stable agents. Rollback is always possible.

Rules-as-code

Click to explore

AI behavior is authored, versioned, reviewed, and approved through standard engineering workflows — same rigor as application code.

Security by design

Click to explore

No source code transfer. Air-gap capable. Runs inside the organization's perimeter.

Batteries included

Click to explore

Ships proven defaults from real-world projects. Makes the right thing the easy thing.

How It Works

Rosetta structures every AI task into five deliberate phases. Reusable prompts apply without modification for each service — consistent, governed results across every IDE and every team. Human review at each transition is critically important.

Phase 1
Preparation
Codify the task as reusable prompts. The task is repeatable and can be structured once, then applied everywhere.
  • Business & technology context
  • Replace old patterns with modern counterparts
  • Update tests, move components, update dependents
Phase 2
Research
AI identifies all affected code parts needed to perform the task.
  • Dependencies & dependents of migrated services
  • Project structure: modules, imports, libraries
  • Legacy code to rewrite, bridge between frameworks
Phase 3
Plan
Generate a detailed, resilient step-by-step plan split into phases that mimic the engineer's workflow.
  • Small code changes per phase — review before they apply
  • Task description, motivation, and required change per step
  • Automated validation (e.g. unit tests) at end of each phase
Phase 4
Act
Implement the plan one phase at a time. Resumable across sessions — same prompt continues where it left off.
  • Phase completion tracked inside the prompt itself
  • Grounding rules enforced: tests run, commits after each phase
  • New session picks up with the same prompt if context fills
Phase 5
Validate
Integrated QA by AI — verifies the implementation against specs for the product's API and UI.
  • Systematically validates implementation against specs
  • Implements integration and E2E tests
  • Compatible with subagents and background agents