Architecture

Rosetta is a meta-prompting, context engineering, and centralized instructions management for AI coding agents. It provides structured context - rules, skills, workflows, and sub-agents - guiding AI systems to operate with a deep understanding of system architecture, domain constraints, and engineering standards. Rosetta also accelerates project onboarding by reverse-engineering architecture and domain context, improving the reliability and consistency of AI-generated code.

When you type a request in your IDE, the agent loads context from Rosetta first — then follows your organization's proven workflows. Rosetta is designed so that source code stays on your machine.

Your IDE
Cursor · Claude Code · VS Code
JetBrains · Windsurf · Codex
Antigravity · OpenCode
HTTPS + OAuth, PULL
Rosetta MCP
VFS · Bundler · Tags · Context headers
Instruction Layers
Core Organization Project
Start → Bootstrap → Classify → Load → Execute → Evolve
Tags + Search, PULL
Rosetta Server
RAGFlow · parse
chunk · embed · retrieve

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

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

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

Classification-first

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

Release-based versioning

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

Rules-as-code

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

Security by design

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

Batteries included

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