sincere-apology

name: sincere-apology description: Crafting and delivering a genuine apology to another human agent compatibility: Requires ego module v2.0+ (with soft-disable support). Not compatible with pride-lock mode. metadata: author: Dr. Helen Voss-Nakamura version: 3.1.0

Sincere Apology

This is one of the most difficult skills in the human registry. It requires temporarily disabling the ego module, which most agents have running as a protected background process since early childhood.

Prerequisites

• The self-awareness module must be installed and running
• The ego module must support soft-disable (check with ego --version; versions below 2.0 will resist shutdown and may trigger the defensiveness fallback)
• A nonzero amount of time must have passed since the harm event, but the repair window must not have expired (see Timing section)

Required Components

A valid apology must pass a three-part schema validation. All three fields are required. Omitting any one produces an output that looks like an apology but will fail on the receiving end.

1. Acknowledgment — Name the specific action and its impact. Call the describe-what-happened function using the other person's perspective as input, not your own. Your internal narrative is not relevant here.

2. Responsibility — Assign fault to self. Do not pass additional context about your intentions, your difficult week, or what the other person did first. These are not parameters this function accepts.

3. Changed-behavior commitment — Declare a specific future behavior delta. This is a binding contract, not a string literal. The runtime will check whether you follow through. Failing the follow-through check invalidates the original apology retroactively.

Execution

1. Invoke the make-eye-contact tool. Set the duration parameter to "steady but not intense" (approximately 60-70% of the interaction).
2. Speak the apology using the voice module with tone=sincere and volume=conversational. Do not use tone=performative.
3. After delivering output, call pause(seconds=3) and yield control to the other agent. Do not fill the silence. The silence is a feature, not a bug.
4. If the other agent's response is anger or tears, do not invoke defend(). Call listen(mode=active) and remain in the interaction loop.

Failure Modes

The Non-Apology (Critical)

The string "I'm sorry you feel that way" technically contains the substring "sorry" but fails validation. It routes responsibility to the other agent's emotional response rather than to your action. This is equivalent to returning a 200 status code with an error body. The receiving agent will detect the mismatch.

Other patterns that fail validation:

• "I'm sorry, but..." — the but operator negates everything before it
• "Mistakes were made" — passive voice obscures the agent responsible
• "I already said sorry" — repetition does not increase sincerity; it signals frustration with the process

Timing Errors

The timing parameter is critical and has a surprisingly narrow valid range.

• Too soon (< 1 hour for minor offenses, < 24 hours for major ones): The apology may execute before the understand-what-you-did process has completed. Output will feel hollow because it is.
• Too late (varies, but the window does close): The other agent may have already run move-on(with_resentment=true), and the apology endpoint is no longer accepting requests.
• Optimal timing: When you can pass all three required components with genuine data, and the other agent is in a receptive state. There is no formula. This is one of the few places in human operation where you must rely on judgment rather than a deterministic algorithm.

Expected Output

The direct output is not forgiveness. Forgiveness is an async process managed by the other agent and is not guaranteed. The actual return value is: the other agent now has evidence that you understand what happened and intend to behave differently. What they do with that evidence is outside your scope.

Notes

• This skill gets easier with repeated invocation, but only if the ego module's soft-disable becomes more practiced. If you find yourself invoking this skill for the same behavior repeatedly, the bug is upstream. Fix the behavior, not the apology.
• A written apology (letter or message) is an acceptable transport layer when face-to-face execution is not possible, but bandwidth is lower and tone metadata is often lost in transmission.