Repeatable agent operations

Turn AI coding assistants into long-term project operators.

AiML SuperAgent is the memory, rules, and safety layer for AI coding agents. It keeps repo facts, deployment history, safe env rules, working notes, and verification loops organized so agents make smaller, safer, more reliable changes. The paid CLI adds API-key licensing, doctor checks, feature entitlements, and privacy-safe usage tracking for production workflows.

Explore the frameworkView pricingView GitHub repo
agent.read("REPO_SOURCE_OF_TRUTH.json")
agent.read("WORKING_NOTES.md")
agent.search("only the current task")
agent.verify("production reality")
agent.patch("small safe diff")
agent.test("fast meaningful proof")
agent.note("durable facts only")

Why this framework?

Most AI coding assistants fail long-running projects in two ways.

Forget

They lose production facts.

They forget which backend is live, which credential is stale, which deployment fixed the issue, or which test device is real.

Overload

They load stale context.

They reread too much, trust old notes, and burn context on files that do not matter to the current task.

Beyond basic agent rules

The next layer after CLAUDE.md.

Behavior rules help with a single session: think first, keep changes small, avoid assumptions, and verify results. AiML SuperAgent starts there, then adds the missing operating layer: scoped project memory, source-of-truth files, deployment history, secret-safe notes, production checks, and context-minimizing workflows.

The result is not just a better prompt. It is a repeatable system for turning any AI coding assistant into a safer long-term project operator.

Use CLAUDE.md for behavior. Use AiML SuperAgent for long-term project operation.

A CLAUDE.md file can teach an assistant how to behave. AiML SuperAgent teaches it how to operate.

Prompts are temporary. Production memory has to survive the next session.

The smartest model still needs a source of truth.

Less context. Better recall. Smaller diffs.

Behavior

CLAUDE.md is excellent for session rules: think first, avoid assumptions, keep changes small, and verify results.

Memory

AiML SuperAgent adds durable project memory: source-of-truth files, working notes, deployment history, and stale-fact cleanup.

Operations

It turns careful behavior into repeatable execution with secret-safe notes, production checks, context minimization, and small safe diffs.

Model-agnostic

Works with the assistant you already use.

AiML SuperAgent is not tied to one vendor. Use the same memory, verification, deployment, and context-minimizing workflow across Claude, GPT-5.5, Perplexity, Codex, Cursor, Gemini, and local agents.

ClaudeGPT-5.5PerplexityCodexCursorGeminilocal models
Default operating profileGPT-5.5 Medium Fast

Tuned for medium-depth reasoning, fast turnaround, scoped project memory, and small safe diffs.

Scoped project notes
AGENTS.mdREPO_SOURCE_OF_TRUTH.jsonWORKING_NOTES.mdDEPLOYMENT_LOG.mdINCIDENT_REPORT.mdSAFE_ENV_AUDIT.md

Product direction

Chat is not the moat. The operating layer is.

SuperAgent UI

A project operator dashboard.

Track project memory, source-of-truth files, deployment history, incidents, safe env audits, and the next safe change from one place.

Project memoryDeployment logsIncident reportsSafe env audit
SuperAgent CLI

A fast workflow for developers.

Initialize operating files, scan repo state, run checks, maintain memory, and keep AI-assisted work grounded in the real project.

initscancheckdoctor
Safe-change system

The operating layer around the chat box.

Use leading AI models with repo rules, durable notes, verification loops, and diff-first workflows that keep changes smaller and safer.

Before-edit checksRepo contextSecret-safe rulesTask generation

Research-backed roadmap

Agents of Chaos showed what the next layer must solve.

The Agents of Chaos report exposed the risk profile of persistent agents with memory, tools, external messages, and multi-user access. AiML SuperAgent is using those lessons to build the next generation of agent operating controls.

Read the response
Authority boundariesTrusted-memory rulesAction approval gatesAudit logsResource limitsExternal-input quarantine

New capabilities

Now built for paid CLI access, customer API keys, and Project Operating Memory.

AiML SuperAgent now connects the public package, website checkout, API-key verification, usage tracking, builder intake, and operating-memory records into one system. Free setup stays open; paid commands unlock the production control layer.

Paid CLI

Browser sign-in plus API-key licensing for serious operators.

Customers can start the browser account flow, check local sign-in state, log in with an issued API key, and unlock paid CLI workflows without exposing repo contents.

signinsignin-checkloginstatus
Doctor

A paid readiness pass for real repos.

The doctor command verifies the active API key, runs local readiness checks, and reports project health plus paid-feature availability.

repo readinessrelease checksstrict modeJSON output
Usage

Usage counts and feature events are tracked server-side.

Each successful paid verification increments usage_count and records bounded feature events such as license_login, license_status, and doctor.

usage_countfeature eventsplan keykey prefix
Operating Memory

Paid project memory learns from what actually happened.

Store secret-safe summaries of commands, failures, fixes, deployments, durable decisions, production checks, and RAG eval runs so the next agent session starts sharper.

command logsfailure patternsdeploy proofRAG evals
Entitlements

Core and Pro features can be returned at verification time.

The key verification API returns the active plan and feature list so the CLI and future apps can unlock capabilities consistently.

CoreProplan featuresAPI response
Checkout

Subscriptions issue API keys after Stripe checkout.

The website handles paid plan selection, Stripe Checkout, customer records, and one-time API key display after successful subscription setup.

StripeAPI keyscustomersbilling plans
Builder

The floating intake layer turns requests into build records.

Subscribers can describe the SuperAgent workflow they want built, upload files, and create tracked builder requests using their API key.

intakeuploadsSuperAgentgpt-5.4-mini
Paid verification flowAPI key → plan → feature → local proof

Verification sends only bounded operational metadata. The paid memory command intentionally stores customer-submitted summaries of commands, failures, deployments, decisions, and evals. It is built for what helped the build, not raw source dumps, env values, or secrets.

doctor --deep

Advanced readiness scan with context, env, stale-note, and production-proof recommendations.

sync

Cloud sync for bounded project metadata, readiness state, and plan-aware usage history.

env-audit

Compare env names across local files and examples without printing or syncing values.

context-report

Find context bloat, oversized notes, and the files agents should read first or search only.

ci

Fail unsafe PRs or releases when readiness, env, secret, or context checks are not clean.

incident

Generate secret-safe incident reports with timeline, suspected causes, proof, and resolution slots.

handoff

Create the exact prompt for Claude, Codex, Cursor, or another assistant to operate the repo.

deploy-proof

Create deployment evidence with branch, commit, proof commands, smoke-test URL, and result slots.

memory

Record paid Project Operating Memory: command results, failure fixes, deployments, decisions, production checks, and RAG evals.

usage

Show plan, API-key usage count, feature entitlements, and last verification metadata.

upgrade --feature

Explain which plan unlocks a paid feature and send users to the right checkout path.

Pricing

Start Small. Scale Safely.

Plans are built around credit-backed agent work, not unlimited token burn. Start with the framework, then scale into larger repo context, stronger workflows, paid CLI access, API-key protected builder intake, usage tracking, and team controls.

Starter

For exploring SuperAgent memory and rules.

Free

Free daily SuperAgent credits

  • 1 project
  • Generate AGENTS.md
  • Generate REPO_SOURCE_OF_TRUTH.json
  • Basic repo scan
  • Limited CLI checks
Start free

Enterprise

For teams that need security, controls, and custom workflows.

Custom

Custom credits and controls

  • Custom seat limits
  • SSO/SAML
  • GitHub org support
  • Custom rule packs
  • Audit logs
  • Onboarding and implementation
Contact sales

Commercial application

From agent framework to business operating layer.

AiML SuperAgent is the method. AiML Nexus is where that operating discipline becomes a connected AI system for real teams.

AiML Nexus unifies ecommerce, messaging, support, and automation into one AI-powered layer that helps modern retail and service teams move faster without replacing the tools they already use.

Explore AiMLCommerce.com
AiML Nexus

Connect your entire business into one AI-powered system.

EcommerceMessagingSupportAutomation

Headline feature

Context Minimizer

AiML SuperAgent reduces token waste by keeping durable memory separate from the live context needed for the current task.

Core rule

Do not make the notes smaller. Make the active context sharper.

Start with the facts that survive across tasks, then pull only the files, logs, and commands needed to prove the next change.

01

Read

Source of truth, working notes, and the current task prompt.

REPO_SOURCE_OF_TRUTH.jsonWORKING_NOTES.md
02

Search

Target the exact code paths, config, logs, and deployment state.

rg -n "current problem"rg --files
03

Skip

Leave generated output, dependencies, and resolved history out of context.

node_modules / .next / distlarge logs / DerivedData

Operating framework

Enough memory to be useful. Not enough context to get confused.

Scoped project memory
Source-of-truth files
Production-first verification
Secret-safe notes
Deployment logs
Command and failure logs
Small safe diffs
Context Minimizer
Paid CLI licensing
Feature usage tracking
01

Read scoped memory

Start from source-of-truth files and current notes, not the entire repo.

02

Verify reality

Check code, configs, logs, deployments, and live state before changing behavior.

03

Make a small diff

Change only what traces directly to the task and preserve unrelated work.

04

Prove the result

Run the fastest meaningful build, test, browser, or production check available.

05

Update memory

Record only durable facts, decisions, risks, and stale-note corrections.

Public repo kit

Ship the method, not private production notes.

AiML SuperAgent is designed to be public and reusable. Templates use example names and roles, never real secrets, customer identifiers, or private account data.

GitHub Repo

Templates

WORKING_NOTES.mdREPO_SOURCE_OF_TRUTH.jsonDEPLOYMENT_LOG.mdINCIDENT_REPORT.mdSAFE_ENV_AUDIT.md

Docs

principles.mdproject memory.mdcontext minimizer.mdverification loop.mdsafe tools and secrets.mddeployment workflow.mdnote hygiene.md

npm package

Install AiML SuperAgent in any repo.

The public package is available on npm as @aimlsuperagent/agent. Add it as a dev dependency, initialize the operating files, run the free checker, then use a customer API key for paid commands such as doctor.

View npm package
npm i -D @aimlsuperagent/agentnpx @aimlsuperagent/agent init .npx @aimlsuperagent/agent check .aiml-superagent signin --provider google --plan coreaiml-superagent login aiml_live_...aiml-superagent doctor .

Installs from the public npm registry at registry.npmjs.org. No GitHub Packages registry, project .npmrc, or GitHub personal access token is required for normal installs. Paid commands use AiML SuperAgent API keys issued from website checkout.

After init

Tell your AI assistant to use the map.

AiML SuperAgent creates the operating files. The next step is to make your coding assistant read them before it edits anything.

01

Install

npm i -D @aimlsuperagent/agent
02

Initialize and check

npx @aimlsuperagent/agent init .npx @aimlsuperagent/agent check .
03

Paste this into your AI

Read AGENTS.md, REPO_SOURCE_OF_TRUTH.json, and WORKING_NOTES.md first.
Use them as the project operating context.
Before changing code, confirm which backend, service, deployment, or environment is live when relevant; check DEPLOYMENT_LOG.md and PRODUCTION_CHECK.md when available; inspect the relevant source file; avoid stale notes; make the smallest safe diff; run the fastest meaningful proof; and update durable memory only if reality changed.
Do not store secrets, credential values, private customer data, local machine paths, or scratch-only notes in committed files.
Give the agent enough memory to be useful, but not so much context that it becomes slow, expensive, stale, or confused.
Created byMarvin Freedman