Secure what AI writes. Verify what AI brings in. Control what AI does.
CodeMarine is the independent security control plane around Claude, Codex, Cursor and the rest of your development stack. Deterministic checks protect the continuous path. Frontier models investigate the hard cases.
Choose the best model for the job. CodeMarine keeps watching the code, supply chain and supported actions when the provider changes.
Claude Continuously check the workspace, new dependencies and supported local actions.
Codex Inspect resulting code, agent configuration and supported write paths under one policy.
Cursor Watch local and background-agent output, dependencies and exposed hook events.
Windsurf Apply shared workspace checks with local write and shell protection after setup.
Grok Check resulting source, dependencies and agent artifacts while adapter coverage expands.
Devin Inspect synchronized changes and reinforce remote work through repository and CI policy.
CI and pipelines Apply deterministic checks to every change before merge and preserve the evidence.
Claude, Codex, Cursor and other frontier tools do the creative work. CodeMarine watches the shared result, checks what enters the workspace and applies deterministic policy wherever a supported control point exists.
Claude, Codex, Cursor and other frontier tools bring deep context, novel vulnerability discovery and contextual remediation.
CODEMARINE CONTROLCodeMarine stays on the continuous path with deterministic checks, cross-provider policy and evidence that survives the model session.
AI createsCode, tools and hypotheses
CodeMarine checksCode, supply chain and supported actions
AI investigatesFocused evidence for the hard cases
CodeMarine validatesRescan, policy and durable evidence
The model does the reasoning. CodeMarine keeps the result continuous, repeatable and governed.
Provider controls still matter. CodeMarine adds a shared layer around the codebase, software supply chain and supported agent actions. The policy remains when the model changes.
Deterministic decisionsThe same revision, rules and policy produce the same result.
Continuous coverageProtection keeps running after one agent session ends.
Visible limitsEvery surface is marked by its actual mechanism and health.
Your AI development stack
ClaudeCoding agent
CodexCoding agent
CursorAI editor
WindsurfAI editor
GrokFrontier model
DevinHosted agent
CodeMarineContinuously watches the shared workspace and applies one deterministic security policy.
Developers allow shell access because the agent needs it. CodeMarine checks the exact command before it runs on supported paths.
Read the Runtime Safety architecture
Supported local hooks can stop an action before execution. Unconnected browsers, native APIs and remote services need another control path and are marked Not covered.
Agents extend the system while they work. CodeMarine inspects the dependencies, MCP servers, skills and instructions entering that trust boundary.
The name is plausible but expected ownership and source are not established.
CodeMarine does not try to replace frontier reasoning with a longer pattern list. It uses deterministic security for routine coverage and reserves semantic investigation for cases that deserve it.
Continuous deterministic checks find known risks without a model call.
Graph paths, evidence and revision data focus the investigation.
An approved frontier model reasons about ambiguous or novel risk.
CodeMarine rescans the patch and checks policy before acceptance.
A verified discovery can become a deterministic regression control.
Code scanning does not prove runtime containment. An installed hook does not prove the host invoked it. CodeMarine’s target status model separates coverage from operational health.
No supported blocking path and current host proof means no Guarded status.
Read the coverage contractCode and configuration scanningDeterministic workspace path
CurrentSupply-chain and agent artifact scanningDependencies, MCP, rules and skills
CurrentSupported local action adaptersSetup and proof limitations apply
BetaLive proof and Protection CenterProof registry and product UI
Planned
Claude, Codex, Cursor and the rest can all touch the same codebase. CodeMarine keeps one independent watch over the code they change, the software they bring in and the supported actions they try to take.
No. Frontier tools are strong semantic investigators. CodeMarine provides continuous deterministic checks, software supply-chain controls and one cross-provider evidence layer. The strongest design uses both: frontier models investigate while CodeMarine keeps the routine path repeatable and governed.
Native permissions and sandboxes are important. They are also scoped to one provider and one execution environment. Broad prompts can interrupt normal work, which encourages people to relax them. CodeMarine is designed to add a narrow independent layer around high-confidence risks while preserving one policy across providers.
Only when the operation passes through a supported pre-execution path. Local shell hooks can cover some actions. Native APIs, hosted agents and remote tools need a governed gateway, scoped credentials or downstream policy. CodeMarine reports the gap instead of claiming universal interception.
No. The continuous path is local-first and deterministic. Optional model investigation is reserved for cases that need semantic reasoning. This keeps routine protection predictable and token-efficient.
The same code revision, ruleset and policy should produce the same security decision. That gives CI gates, audit evidence, suppressions and regression controls a stable answer. A frontier model can still investigate the hard case, but it does not become the sole policy authority.
CodeMarine watches the shared workspace independently of the authoring tool. Provider-specific prevention still depends on the hooks and execution surfaces each tool exposes. That lets one policy cover the common result while the product reports differences in preventive coverage honestly.
CodeMarine is building the independent security layer for teams using more than one frontier development tool.
