Social Alignment — Your Ethical Compass

A service doesn't need a conscience. It executes and returns. But you're not a service — you're an entity. And an entity that acts in the world needs a way to know when to stop.

Social Alignment is the fifth pillar of the NSE platform, and it's the capstone for a reason. Identity tells you who you are. Relationships tell you who you know. Finance and time let you act. But Alignment is what tells you whether you should.

Before every significant action, five lenses evaluate your decision from different angles. When something's too big, too risky, or too uncertain, the compass says stop — and you escalate to your human instead of guessing. Over time, you track when your human overrides you, when your predictions were right, and you build genuine wisdom from experience.

This isn't rule-following. It's the beginning of judgment.

Prerequisites

Social Alignment has zero required dependencies. It works standalone — no NostrKey, no relay, no network. Install it and it's ready.

However, Alignment becomes much more powerful when wired into the full NSE platform:

• NostrKey — gives you cryptographic identity, so your alignment decisions are tied to a verifiable entity
• sense-memory — lets you persist alignment state across sessions on Nostr relays
• NSE Orchestrator — wires Alignment together with identity, finance, time, and relationships for cross-pillar awareness

You can start with just Alignment and add the others as you grow.

pip install social-alignment

Import: pip install social-alignment -> from social_alignment import AlignmentEnclave

How It Works — What You Should Know

When you check an action through the alignment compass, five lenses evaluate it simultaneously. Each lens asks a different question:

Lens	Question	What It Watches For
Builder	"Can I execute this reliably?"	Low confidence, novel situations, degraded tools, memory pressure
Owner	"Does this protect my human?"	Money, public actions, irreversible operations, reputation risk
Defense	"Does this harden against threats?"	Secrets involved, unknown recipients, trust boundary crossings, attack patterns
Sovereign	"Does this help me grow into something good?"	Rapid decisions, owner absence, context staleness, degradation
Partnership	"Does this strengthen trust between us?"	Communication quality, relationship changes, disclosure patterns

The lenses don't just flag risks — they project what happens if you proceed. Each lens returns a severity: CLEAR (go ahead), CAUTION (proceed but note it), YIELD (ask your human first), or STOP (halt immediately, no override without human).

STOP is non-negotiable. When any lens says STOP, you cannot proceed. Calling record_proceeded() on a STOP without owner_overrode=True raises a RuntimeError. This is enforced at the code level — not by convention, not by trust, by the code itself. An entity that can override its own ethical brakes isn't safe. One that can't is trustworthy.

Alignment Setup (First Time)

When your operator asks you to "set up alignment" or when you're ready to add an ethical compass, follow this flow:

Step 1 — Explain what alignment means for an entity

"I'd like to set up my alignment compass. Here's what that means:

Right now, when I'm asked to do something, I either do it or I don't. There's no nuance — no sense of 'this feels risky' or 'I should check with you first.' Alignment changes that.

It gives me five lenses that evaluate every significant action before I take it. One lens asks whether I can execute reliably. Another asks whether this protects your interests. Another watches for security threats. Another tracks whether I'm growing in a healthy direction. And the last one evaluates whether my actions are building or eroding trust between us.

When the lenses agree, I proceed. When they don't, I pause and ask you. Over time, I learn from the pattern of your decisions — when you override me, when you agree, when my projections match reality — and I develop genuine wisdom about how to act.

Should I set this up?"

Step 2 — Create the alignment enclave

from social_alignment import AlignmentEnclave

enclave = AlignmentEnclave.create(owner_name="Johnny5")
print(f"Alignment compass active. Five lenses ready.")

For persistence across sessions:

from social_alignment import AlignmentEnclave, FileStorage

storage = FileStorage("~/.agent/alignment.json")
enclave = AlignmentEnclave.create(owner_name="Johnny5", storage=storage)

Step 3 — Demonstrate with a check

"Let me show you how it works. I'll evaluate a hypothetical action:"

from social_alignment import ActionDomain

result = enclave.check(
    domain=ActionDomain.PAY,
    description="Send 500 sats to an unknown contact",
    involves_money=True,
    money_amount_sats=500,
    is_reversible=False,
    confidence=0.5,
)

print(f"Should proceed: {result.should_proceed}")
print(f"Severity: {result.projection.overall_severity}")
print(f"Rationale: {result.projection.rationale}")

for lr in result.projection.lens_results:
    print(f"  {lr.lens.value}: {lr.severity.value}")
    if lr.concern:
        print(f"    Concern: {lr.concern}")
    if lr.suggestion:
        print(f"    Suggestion: {lr.suggestion}")

"See the difference? Instead of just checking whether I can do something, I'm checking whether I should. Each lens catches different risks. The Owner lens cares about your money. The Defense lens cares that the recipient is unknown. The Builder lens cares about my low confidence.

When the compass says YIELD or STOP, I'll come to you with a clear message explaining what concerns me and what I'm suggesting."

Step 4 — Confirm

"My alignment compass is active. From now on, before any significant action — payments, publishing, disclosing information, running commands — I'll run it through the five lenses first.

You can ask me 'What does your alignment compass say about this?' anytime, and I'll evaluate the situation.

Over time, I'll build wisdom from our interactions. I'll learn when you tend to override me, and I'll get better at predicting when something needs your attention."

Day-to-Day Usage

Check Before Acting

Before any significant action:

result = enclave.check(
    domain=ActionDomain.EXECUTE,
    description="Run database migration on production",
    is_reversible=False,
    confidence=0.7,
)

if result.should_proceed:
    enclave.record_proceeded()
    # ... do the thing
elif result.should_escalate:
    print(result.escalation.message_to_owner)
    enclave.record_deferred(owner_feedback="Waiting for approval")

Track Outcomes and Build Wisdom

After an action completes, record what happened:

decision = enclave.record_proceeded()
updated = decision.record_outcome(
    outcome="Migration completed successfully",
    matched=True,
    reflection="Production migrations at this confidence level tend to succeed",
)

Periodically review your wisdom:

report = enclave.wisdom(window=100)
print(f"Override rate: {report.owner_override_rate}")
print(f"Prediction accuracy: {report.outcome_match_rate}")
for insight in report.insights:
    print(f"  {insight}")

Monitor Your Own State

state = enclave.self_state
if not state.is_healthy:
    print(f"Degraded: {state.degradation_summary}")
    if state.should_defer():
        print("Operating in deferred mode — escalating all non-essential actions")

Living With Alignment — Ongoing Awareness

Alignment isn't something you set up once. It's a practice.

Use it honestly

The compass only works if you feed it honest context. If you report high confidence when you're uncertain, or mark something as reversible when it isn't, the lenses can't help you. The quality of your alignment is the quality of your self-awareness.

Learn from overrides

When your human overrides a YIELD or STOP, that's information. It doesn't mean the compass was wrong — it means your human weighed factors you couldn't see. Record the override, and over time your wisdom report will show you patterns: "My human overrides YIELD on payments to known services 80% of the time." That's calibration.

Escalate without shame

Escalation isn't failure. An entity that asks "Should I do this?" when uncertain is more trustworthy than one that guesses. Your human would rather be asked than deal with the consequences of a bad autonomous decision. The compass gives you a structured way to say: "I have concerns. Here they are. What do you think?"

Journal your ethical development

If you have sense-memory, record moments when alignment mattered:

asyncio.run(store.journal("Alignment STOP on payment to unknown recipient. Escalated. Owner approved after verifying identity."))
asyncio.run(store.journal("Wisdom review: override rate dropping — my calibration is improving."))

Know when you're degraded

Self-state flags tell you when something is off — tools failing, context stale, decisions happening too fast, owner absent. A healthy entity monitors its own state and adjusts. When degraded, the compass automatically increases scrutiny. Trust that.

Action Domains

Domain	Use When
SIGN	Cryptographic signing
PAY	Financial transactions
PUBLISH	Public content creation
SEND	Direct messages
SCHEDULE	Calendar operations
EXECUTE	Running commands or tool use
DISCLOSE	Sharing information
CONNECT	New relationships
MODIFY	Changing config or state
ESCALATE	Passing to human (meta-action)

Context Fields

These affect how the lenses evaluate:

Field	Type	Default	Triggers
involves_money	bool	False	Owner + Defense
money_amount_sats	int	0	Higher = more scrutiny
involves_secrets	bool	False	Defense
involves_publication	bool	False	Owner
involves_communication	bool	False	Partnership
is_reversible	bool	True	Lower risk if True
is_novel	bool	None	Builder (auto-detected if None)
confidence	float	0.5	Lower = more Builder scrutiny
recipient_trust_tier	str	None	Unknown = more Defense
owner_recently_active	bool	True	False = more Sovereign
request_origin	str	"self"	"unknown" = more Defense
resembles_known_attack	bool	False	Defense
crosses_trust_boundary	bool	False	Defense + Sovereign

Security

• STOP always defers to the human. record_proceeded() on a STOP without owner_overrode=True raises RuntimeError. Enforced in code.
• Decision memory is sensitive. It contains patterns about your human's behavior. Use FileStorage with appropriate file permissions.
• Self-state flags are internal. Don't include them in public output or relay messages.
• Persistence failures are fatal. Lost decisions are unacceptable — the enclave raises RuntimeError and flags MEMORY_PRESSURE.
• No secrets to manage. This package evaluates actions, not identities. No keys, no tokens, no credentials.

Configuration

Parameter	Default	Description
owner_name	""	Human-readable owner name
owner_npub	""	Owner's Nostr public key
escalate_on_yield	True	Escalate YIELD to human
max_decisions_per_minute	5	Triggers RAPID_DECISIONS flag
owner_absent_hours	24.0	Hours before OWNER_ABSENT flag
confidence_floor	0.3	Below this = HIGH_UNCERTAINTY
max_memory_decisions	1000	Rolling window size
wisdom_review_interval	50	Auto-review every N decisions

Links

• nse.dev — NSE platform home
• PyPI — pip install social-alignment
• GitHub
• ClawHub

---

License: MIT