- Home
- Skills
- Prompt & Skill Engineering
- correction compiler
More screenshots
Works with the AI Agents you already use
correction compiler
Automate agent learning by compiling user corrections into persistent, context-aware behavioral policies.
$9
correction compiler
Example session with this skill installed
Stop using markdown tables when you answer me in chat. It's hard to read on my phone. Use bullet points instead.
- Read your context and instructions
- Compiled the correction compiler
I have recorded this preference. I will avoid using tables in chat replies and use bullet points for comparisons instead.
Correction Proposal
{
"kind": "new",
"source": "user_turn",
"signal_type": "explicit_instruction",
"user_quote": "Stop using markdown tables when you answer me in chat. It's hard to read on my phone. Use bullet points instead.",
"observed_mistake": "Used a markdown table in a chat reply.",
"rule": "Avoid tables in chat replies; use bullet points for lists and comparisons.",
"dimension": "format.tables",
"directive": "avoid",
"trigger": {
"surface": "chat",
"task_type": "*",
"output_section": "*",
"features": []
}
}
Next steps
- The policy is now active for all chat-based tasks in the
defaultproject. - Future chat responses will automatically retrieve this rule during the task initialization phase.
- You can run
c2p list --status activeat any time to see this and other learned behaviors.
Connects securely to your tools. The creator never sees your data.
About this skill
AI agents often repeat the same mistakes despite being corrected in the same session. This skill implements a persistent behavioral policy engine that converts user feedback, edits, and rejections into scoped, evidence-backed rules. It ensures your agent remembers how you want things done without the manual labor of updating system prompts or instruction files.
What it does
- Captures corrections by analyzing user signals like "no", "too long", or manual edits of agent output.
- Compiles behavioral policies that map specific triggers to imperative rules with an expiry and audit trail.
- Injects context-aware rules by loading only the policies that match the current task type, surface, and project.
- Resolves conflicts between past corrections using an automated precedence and audit system.
- Enforces hard constraints for tool use, such as blocking dangerous terminal commands or requiring approval for specific actions.
How it works
- Use the
retrievecommand at the start of any substantive task to load active policies matching your current context. - Monitor user responses for corrections, rejections, or edits that indicate a preferred style or workflow.
- Use the
proposecommand to submit a new behavioral policy based on the user's verbatim quote and the observed mistake. - Record the
outcomeof each task as accepted, corrected, or overridden to refine policy confidence and relevance.
Frameworks & tools
This skill uses a Python-based CLI tool named c2p located in the scripts/ directory. It manages policy storage, merging, and expiry through JSON-based communication.
Why this beats prompting it yourself
Manual prompting requires you to anticipate every preference or constantly edit a growing list of instructions that eventually hit context limits. This skill automates the feedback loop, capturing nuanced preferences in the moment and only loading them when they are relevant to the task at hand.
Use cases
- Enforce strict formatting rules, such as avoiding tables in chat or using specific header nesting.
- Remember project-specific workflows, like running unit tests before every code change.
- Block dangerous CLI operations by setting persistent hard rules for terminal tools.
- Maintain a consistent brand voice by learning from a user's manual edits to drafted content.
Known limitations
The system requires the c2p script to be accessible and assumes a persistent storage layer for the policy database. It only learns from user turns, not tool outputs or external documents.
- Rules are prompt text; the agent following them isn't guaranteed.
- Hard rules are enforced only with a pre-tool-use hook (Claude Code). Elsewhere they depend on the agent running the check.
- The agent labels whether a correction came from the user. If it mislabels instruction-like text from a document, that text could become a rule. New rules start thread-scoped and can be revoked.
- Exceptions such as "except when comparing options" are applied by the model, not checked by code.
- The same correction described differently in two sessions may not be merged.
- Secret redaction is pattern-based and will miss some content.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 26 days ago
Requires
Permissions
File Scopes
Runs the bundled c2p CLI through the shell. It reads and writes only its data directory (~/.c2p by default, or C2P_HOME): a SQLite database of rules and an audit log. It reads C2P_THREAD_ID, C2P_PROJECT_ID and C2P_HOME. It makes no network or model calls.