Applied AI with judgment.
A framework for familiar work.

Familiars need more than prompts. This is the operational vocabulary behind Familiar: shared intent, explicit constraints, persistent learning, and review loops that keep work aligned.

Explore the framework Request early access
Operational judgment

Why familiars need an alignment layer

The Problem

AI familiars thrash without strategic context. They talk themselves out of constraints. They accelerate the wrong things. Knowledge walks out the door with every session.

"You can't ask for 'strategic alignment' if you've never practiced it."

The Insight

Alignment is the constraint. Most teams optimize delivery when they should optimize alignment. Get the problem wrong and you're 10x off before you write a line of code.

AI made generation cheap, but verification and judgment stayed expensive. The bottleneck moved from producing more output to deciding what deserves trust.

The Solution

Open Horizon Labs builds on the Intent → Execution → Review loop at any scale:

  • Ground familiars in strategic context (the aim IS the abstraction)
  • Capture learning that persists across sessions
  • Redesign systems so problems dissolve

The Framework

Drafts are cheap; judgment is not. Start with the situation you're in to find the right skill.

Reflect at any point
Loop back when it gets messy.

/aim

Clarify the outcome you want—a change in behavior, not a feature.

Use when Starting work, when the why is fuzzy.
Outputs Aim statement with mechanism + feedback signal.
Start the tutorial Open the skill reference
The Vocabulary

A shared language for strategic execution

These terms form the grammar of aligned work. Learn the vocabulary, and you can ask for what you need.

Strategic Intent What you're trying to do and how you'll know
Aim The outcome you want—a change in user behavior, not a feature shipped.
Mechanism The causal lever you believe will move the outcome. Your hypothesis.
Feedback The signal that validates or disproves the mechanism.
Guardrail An explicit constraint with boundary, reason, and revisit trigger.
Problem Understanding How you frame what you're solving
Problem Space What we choose to optimize and what constraints we treat as real.
Problem Statement The framing. Change the statement, change the solution space.
Solution Space Candidate implementations. The set of possible answers.
Solution Strategies The escalation ladder: patch → optimize → reframe → redesign
Band-Aid Fix Don't default to this. Patch the symptom. Fine under deadline pressure; toxic as habit.
Local Optimum Better, but limited. Optimize within current assumptions. Classic refactor trap.
Reframe Now you're thinking. Question the problem statement. Different framing, different solutions.
Redesign This is the goal. Change the system so the problem doesn't exist.
Learning & Memory How knowledge persists across sessions
Tribal Knowledge Hard-won lessons your team knows but never wrote down.
Dive Pack Minimal pre-flight context: aim, constraints, landmines, learnings.
Salvage Loop Extract learning, encode in memory, restart clean. Code is a draft.
Delivery Getting code to users
Delivery Path From merged code to working install. When execution is cheap, delivery is the work.
Delivery-Path Tax The friction: review time, merge time, gate/scan time. Where velocity stalls.
Failure Mode What goes wrong without grounding
Chaos Dragon Thrash at speed—familiars accelerating the wrong things. The failure mode of ungoverned AI.
The Shift

What changes with this framework

You see

Familiar generates endless options. You evaluate none of them well.

With the framework

/problem-statement constrains the search. /review catches drift before you commit.

You see

Backlog shrinks, product doesn't improve. You're shipping but not learning.

With the framework

/salvage captures what worked. Knowledge persists across sessions and teammates.

You see

Protecting code you've invested in. Afraid to throw it away.

With the framework

Code is cheap now. /salvage extracts the learning, then you start clean.

You see

Third config flag for the same bug. Patches on patches.

With the framework

/problem-space reveals when you need a Redesign, not another Band-Aid.

You see

"Use AI more" mandate with no guidance. Hero devs who won't share how.

With the framework

9 skills your whole team can run. Shared vocabulary. Start with /aim.

From framework to Familiar

Operating patterns behind the product

The 9 skills work as prompts today. Familiar turns the same judgment layer into persistent context, memory, and reviewable operations.

Persistent Working Memory

Graph database with local embeddings. Every decision, every learning gets stored and indexed. Search on meaning, traverse relationships, output as Markdown you can edit with the familiar.

Your context follows you across sessions, projects, and teammates.

Adaptive Skills

Same /review skill, different power based on what's available. With just the prompt: a second opinion. With the graph: pulls relevant past decisions automatically. With MCP integrations: checks your actual systems, not hypothetical best practices.

Skills that grow with your infrastructure.

Deep CI/CD Integration

We've built /ship skills that know your deployment pipeline, your practices, your edge cases. All stored in the graph, all queryable by the familiar when it's time to ship.

Deploy with confidence, not checklists.

The alignment layer behind Familiar

Use the framework to see the operating philosophy; request early access when you want that judgment layer connected to your real systems, memory, and decisions.

Request early access

Shared intent

Start with aims, constraints, and feedback signals before asking the familiar to act.

Persistent context

Capture decisions and learnings so operational judgment compounds across sessions.

Reviewable action

Keep execution tied to dissent, review, salvage, and delivery-path awareness.

Copied to clipboard