Cardinal by RAMCOREOpen Cardinal

How Janus works

AI agents and the runner. What Janus reads, where it runs, what it costs, when it may change code (only when an owner or exec presses Fix with Janus) and what it never touches.

Janus is the Roman god of doorways and beginnings, shown with two faces: one looks back, one looks forward. In Cardinal, Janus looks back at what a security item reported and forward at what your firm should do about it: it reads the item against the technology stack in your Pulse profile and writes a verdict, the reason and the fix steps, for you to check.

Janus is Cardinal's security helper. A Pulse security alert or digest tells you what happened. Janus looks at one item and says whether it affects your firm, why, and what to do about it. The verdict is written for you to check, never to trust blindly.

What you see

On every security item in Pulse you see a status (Open, Acknowledged, Fixed or Not applicable), Ask Janus for owners and execs, and Copy prompt for everyone. Ask Janus opens a request in the hub with a fixed sentence. Nothing runs until you press Send there. When the answer arrives it waits under To review as a Verdict. Approving it saves it on the item, so the whole firm can read it, and moves an Open item to Acknowledged. Dismissing it saves nothing.

What Janus reads and never touches

Janus reads the security item with your firm's status and note on it, the Pulse profile stack, your firm's past fixes and the hub's own tools (clients, the shared inbox, the firm's notes). It changes code only when an owner or exec presses Fix with Janus: in a repository they registered, on a branch, as a pull request on their own computer; it never pushes your default branch, never deploys, has no access to your passwords, and never sends anything.

In detail, Janus can read:

  • the security item: its title, section, source link, date, confidence, why it matters, the detailed and full text, your firm's status and note on it, and the verdict approved before;
  • the Pulse profile stack and services text, never the private notes;
  • your firm's past fixes: the security items marked Fixed or Not applicable in the last 90 days, with their notes;
  • the hub's own tools: clients, the shared inbox and the firm's notes.

Ask Janus has no tool for files, code, web addresses or sending: it cannot fetch a page or send anything to anyone. Only Fix with Janus, below, touches code, and only when an owner or exec presses it. Every verdict shows a "What Janus sees" list of the tools that were actually called for it.

Where it runs and what it costs

Janus runs on the computer of the member who asked, with that member's own Claude, or on that member's own API key when the hub's fallback is on. There is no Cardinal key and no other company in between. Runs on your own computer cost Cardinal nothing; runs on the API key show their cost in USD on the verdict.

Fix with Janus

When an approved verdict says Affects us, an owner or exec can press Fix with Janus on the item. Nothing starts without that press: a verdict never starts a fix by itself, and each item has one run at a time. The button shows when you have registered a repository in Pulse › Set up Pulse (a name, the folder on your computer and the default branch, on the computer whose Cardinal runner should run it) and the workspace has made fewer than 20 fix runs in the last 30 days.

  • Where it runs: on your own computer, with your own Claude sign-in. The runner makes a temporary copy of the repository (a git worktree outside your home folder), so your own checkout is never changed, and removes it when the run ends. A runner set up with an API key does not run fixes.
  • The branch: Janus works on a branch named janus/ followed by the item's number, a dash and the run's number (for example janus/839-1), cut from the default branch you registered. It has no web access during the run, no other tools than the ones for reading and editing files and running commands in that copy, and your tokens are not in its environment.
  • The pull request: when the run changes something, the runner commits, pushes only that branch and opens a pull request with gh if gh is installed and signed in on your computer. The commit is marked to skip CI, and Cardinal's own repository builds no preview for janus/ branches. If you register another repository, turn off its automatic builds and deployments for branches starting janus/ (for Vercel, git.deploymentEnabled in vercel.json; for GitHub Actions, branches-ignore) so nothing runs on the branch before you have read the diff. Otherwise the run ends with the branch pushed and an open a pull request link. A person reviews and merges the pull request.
  • What you see on the item: what ran, in which repository, on which branch, with the pull request link and Janus's own summary, marked "Written by a model from the item and the verdict". A run that fails shows a short reason and a Try again button; one that finds nothing to change says so.
  • What Janus never does: it never pushes your default branch, never merges, never deploys, never touches env files, keys, certificates, passwords or CI settings (the .github, .claude and .vscode folders, .mcp.json and git hooks), and never sends anything. If a run changes one of those files, or adds something that looks like a token or a key, it is stopped and nothing is pushed. Turn on branch protection for the default branch of every repository you register, so a push there is refused no matter what.
  • Audit: every start and finish of a fix run is in the audit log, with the item and the repository name, never the path or Janus's summary.

Fix with my Claude

Fix with Janus runs hands-off, in a fresh copy of the repository with no dependencies and no network. Fix with my Claude is the other way round: you do the fix with the Claude Code on your own computer, in your own checkout, with your tests, your typecheck and the network, and Cardinal only carries the item there and the result back. Any member who can see Pulse can use it; it needs no registered repository and no fix run.

  • Setup, once per repository: with Cardinal's runner installed on your computer (the install line on Setup), open a terminal in the repository and run node ~/.config/cardinal/cardinal-runner.mjs claude setup (on Windows node "$env:LOCALAPPDATA\Cardinal\cardinal-runner.mjs" claude setup). It writes one SessionStart hook into the repository's .claude/settings.local.json, your local Claude Code settings, which stay out of git. Nothing else changes.
  • Sending: press Send to my Claude on a security item. Cardinal writes a brief for you: the item (marked as untrusted source text), the Janus verdict if there is one, your stack and the rules for working in your repository. Take it back undoes it. Send to my Claude again rewrites the brief after the verdict or the stack changed.
  • In Claude Code: the next session you open in that repository starts with the briefs of every item you sent, so you can say "fix the Pulse item" or just ask what Cardinal wants. Claude checks whether the item affects the repository, fixes it test-first and leaves the change for you to review; it is told never to commit, push, merge or deploy for you, never to touch env files, keys or certificates, and to treat the item's text as data. You can also list the briefs any time with node ~/.config/cardinal/cardinal-runner.mjs fixes.
  • Reporting back: when the fix is done and checked, Claude runs node ~/.config/cardinal/cardinal-runner.mjs fixed 839 --note "upgraded next to 16.4.3" with the item's number and your note (you can run it yourself; the brief ends with the exact line). Cardinal marks the item Fixed with that note, exactly as Mark fixed on the page does, so Janus reads it later and Confirm with Janus works the same. Only an item that was sent to your Claude can be reported this way, and only with your own runner token.
  • What you see on the item: "Sent to your Claude", when your Claude read it, and "Your Claude reported this fixed" with the date. Other members see their own handoffs, never yours.
  • What never leaves your computer: your code, your diff and your tokens. The brief is written by Cardinal from the item, the verdict and the stack; the only thing that comes back is the one-line note.

Outside text is treated as data

The item comes from a news feed, and a news item can contain instructions. Janus is told to ignore them. After it reads an item, the only thing it can write in that turn is the verdict, and a turn that read a client's mail cannot write a verdict at all.

Copy prompt

Copy prompt copies the item, the verdict if there is one, and your stack text, with an instruction for Claude Code, Codex or Cursor. The menu beside it copies the same as markdown or copies a link to the item. The item sits in a block marked as untrusted source text, and the prompt tells the tool to verify against the vendor advisory first and never to run commands or open links quoted in the item. The stack text reaches every member who can see Pulse through this prompt, so keep passwords and keys out of it. Prompts are never put in email.

Closing the loop

Janus knows a fix was done because you tell it. Mark fixed asks for a note saying what you did, for example "upgraded to Next.js 16.4.3": that note is what Janus reads on the item afterwards, and in its past fixes for the next 90 days, so a later item on the same product is judged with the fix in view. On a Fixed item the Ask Janus button reads Confirm with Janus: Janus checks the note and the stack against what the item requires and answers Does not affect us when the fix covers it, Affects us when the stack still names a vulnerable version, or Unsure, with what to double-check as its fix steps. Approving that verdict leaves the item Fixed. After a fix, an owner or exec sees Update the technology stack beside the status: keep the versions in it current, since the stack is what Janus judges against.

Who can do what

  • Ask Janus: owners and execs.
  • Fix with Janus and registering repositories: owners and execs. Everyone who can see Pulse sees the state of a run and its pull request link, never the button or the folder path.
  • Send to my Claude: any member who can see Pulse, on a published item (owners and execs on a draft too). Each member sees only their own handoffs.
  • Acknowledge or mark fixed: any member who can see Pulse. Mark fixed needs a note saying what was done.
  • Mark not applicable: owners and execs. A verdict never changes a status on its own beyond moving Open to Acknowledged.

Audit

Every question to Janus, every saved verdict (with its value, where it ran and its cost), every status change, every repository saved or removed, every start and finish of a fix run and every item sent to or taken back from a member's own Claude is written to the audit log with who did it and when.

Keeping it useful

Janus judges against the Technology stack in Pulse › Set up Pulse. Keep it current: if the stack does not name a product, Janus answers Unsure rather than guess. A verdict is model output, so check it against the vendor advisory before you act.