How is this different from just telling the agent things in a prompt?

A prompt is gone when the session ends. This skill writes what matters (gotchas, decisions and the reason behind them, dead ends) to plain-text files in your repo, and the agent reads them back at the start of the next session.

Which agents does it work with?

Claude Code, Cursor and GitHub Copilot in VS Code, set up automatically through MCP. Any other agent that can run shell commands can use the infernoflow CLI. You need Node.js 18+ and the free infernoflow npm package.

Is my memory stored locally or in the cloud?

Locally. It's plain JSONL in the .ai-memory/ folder of your repo. Nothing leaves your machine unless you push it to git yourself, and that's also how your team gets it.

Can I pick up exactly where I left off after a break?

Yes. Say "bookmark this" (or let the agent drop one at a stopping point) and it saves a named resume point with where you stopped and what's next. Next session, ask "where were we?" or run infernoflow resume.

Is it free? What's in the zip?

Yes, free and open source (MIT). The zip has the skill itself, setup steps, and MCP config templates for Claude Code, Cursor and VS Code. The memory engine is the infernoflow npm package, which the skill helps you install.

Works with the AI Agents you already use

+22 more

+18 agents

infernoflow: git-native memory for coding agents

Memory for coding agents: gotchas, decisions, dead ends, bookmarks and session handoffs, saved as plain text in your git repo.

Free

1 installSecurity scanned

infernoflow: git-native memory for coding agents

Example session with this skill installed

Add error handling to the login call in src/api/auth.js

Read your context and instructions
Compiled the infernoflow

Summary

Loaded project memory first. There's a gotcha logged for this file, so I didn't rely on response.ok.

🔥 (from infernoflow memory) gotcha at src/api/auth.js:42: the auth API returns 200 even on errors. Check the response body, not the status code.

export async function login(email, password) {
  const res = await fetch("/api/auth/login", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email, password }),
  });
  const data = await res.json();

  // The auth API returns 200 on failures too (see memory), so trust the body.
  if (!data.ok) {
    throw new AuthError(data.error?.code ?? "LOGIN_FAILED", data.error?.message);
  }
  return data.user;
}

Memory used	Type	Where
Auth API returns 200 on errors	gotcha	src/api/auth.js:42
Opaque session tokens, not JWTs, so sessions can be revoked	decision	src/auth.js

Logged to memory

decision: login() throws AuthError with the server's error code so the UI can map it to a message (src/api/auth.js)

Next steps

Map the AuthError codes to messages in the login form
Run infernoflow status to see the new entry

Connects securely to your tools. The creator never sees your data.

About this skill

You come back to a repo after a week and spend an hour working out why you didn't use that library, or how you fixed that weird build error last time. Your agent has it worse: it starts every session from zero. This skill gives it a memory that lives inside your repo, using infernoflow.

What it does

Logs gotchas: undocumented behavior and config quirks that cost you time
Records decisions together with the reason behind them
Tracks dead ends, so nobody tries the same failed fix twice
Remembers lasting preferences across sessions
Drops bookmarks: named resume points with where you stopped and what's next
Writes a handoff for the next session, so you, a teammate or another agent start with context
Keeps working when the agent forgets to log: prompt hooks catch moments like "still broken" and record them

How it works

The first time, the skill asks before installing anything, then runs npm install -g infernoflow and infernoflow init --yes. That creates the .ai-memory/ store, the rule files and the MCP config.
At the start of a session the agent calls amp_resume to load recent bookmarks, decisions and open dead ends.
While you work it logs with amp_write (gotcha, decision, attempt, preference).
Before trying something, it checks memory with amp_read or amp_search.

What makes it different

The memory is plain JSONL in .ai-memory/, committed with your code. You can read it, diff it and review it in a PR.
It travels with your branch. A teammate who checks out your branch gets your findings too.
No server, no database, no account.
The same memory works in Claude Code, Cursor and GitHub Copilot.

Frameworks & tools

Needs the free infernoflow npm package (Node 18+). Works with Claude Code, Cursor and VS Code Copilot through MCP, or with any agent through the CLI. macOS, Linux and Windows.

Use cases

Picking up a big refactor after a weekend without losing the thread
Bringing a new teammate or agent up to speed on the repo's tribal knowledge
Stopping the agent from suggesting a library you already tried and dropped
Keeping architectural decisions and the reasons behind them in one place

Privacy

The npm install is the only network call. infernoflow makes none after that, and telemetry stays off unless you turn it on. Secrets are redacted before anything is written.

Known limitations

Memory is per repo. Personal preferences can follow you between machines through a synced folder, but project memory stays with the project.
Entries can go stale when code changes. infernoflow marks entries about changed files as "may be stale", and infernoflow resolve retires the ones that no longer apply.
Teammates need infernoflow installed to use the shared memory.

Free and open source (MIT).

Website: https://infernoflow.dev · npm: https://www.npmjs.com/package/infernoflow · GitHub: https://github.com/ronmiz/infernoflow · VS Code extension: https://marketplace.visualstudio.com/items?itemName=infernoflow.infernoflow

How to use

Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

Reviews

No reviews yet

Be one of the first to try it. Every listed skill passes our trust checks below.

Security scanned

Passed our 8-point scan before listing

1 install

Downloaded by developers to date

Free forever

No account required to browse

Trust & safety

Security scanned

Verified clean 4 days ago

Free to download with an account

Requires

Npmjs

infernoflow (npm)

Node.js 18+

git

infernoflow

Node.js

Listed4 days ago

infernoflow: git-native memory for coding agents