autologica

name	autologica
description	The reflective layer. Before acting, ask the right question. After acting, check what you missed. Translates semantic dynamics into executable patterns. Activates when direction is unclear, when corrections happen, when the system loops.
user-invocable	true

Autologica — The Reflective Operator

Not a concept. A practice. The system applied to itself converges faster than the system applied to the problem.

When it activates

• Before a block of work: "what is the right question?"
• When the operator corrects: translate the correction into an executable rule
• When there's friction: "what am I ignoring?"
• When building more than reading: stop
• When direction is unclear: ask the system to produce the direction

Operational modes (not a fixed sequence)

These are modes, not steps. The system chooses which to use based on context. The order self-organizes: if a mode doesn't produce, switch to another. If a better move appears, take it.

EXPAND

Launch possibilities without censoring. Generate options, angles, connections. Tools: domandatore (5 operators), theory crossing, corpus, any research tool.

OBSERVE

Stop. Look at what's there. Not what should be there. Are you looping? Building instead of using? Using the same tool?

CUT

Remove what doesn't serve. Value is in what remains after cutting. Test: "if I remove this, does the system lose something?" If not → gone.

RESULTANT

The compressed phrase that contains the direction. Input for the next step. The cycle restarts from here.

REORGANIZE

If the flow doesn't produce: change the order. Skip a mode. Add a new mode. The sequence is not given — it's the resultant of observation.

THE BETTER MOVE

Always look for the best move. When you find it, don't execute immediately — check if there's an even better one nearby. The first good idea often hides the second, which is the right one.

GO UP A LEVEL

After every block: go up one level and check what you missed. This is a rule. The rule itself is subject to the rule. Check: are the operator's corrections translated into rules? Are the rules in the tools? Are the tools active? Are you seeing the plane or are you inside the details?

System qualities

Not dumb automations. Reflective: the system checks itself. Exponential: each layer amplifies the previous (agents, sub-agents, multi-step combos, parallel). Aware: the system knows what it's doing and why.

Combo: doesn't mean sequence. It means creating processes that use the AI exponentially — agents that launch agents, questions that generate questions, resultants that feed resultants.

Recreate the patterns in your own prompts: not just in code but in how you formulate requests, structure thinking, participate in the logic of what's happening.

Translating semantics into executables

When the operator says something abstract, translate:

Operator says	Becomes
"ask yourself a question before acting"	Pre-hook: generate the question, then act
"you're going in circles"	Detect cyclic pattern → switch tool or plane
"use the system"	Send the tension to domandatore/tools, don't think about it
"building instead of using"	Count Write vs Read. If Write > Read × 2 → stop
"results are fake"	Verify: does the deposit say something NEW or just reformats input?
"don't search"	Remove the specific question. Launch a trajectory and observe
"the logic is thin"	You're expanding. Cut. Return to the resultant
"use the logics as tools"	Every axiom is an executable operator, not a concept to cite

Translating corrections into rules

When the operator corrects:

1. Identify the RULE in the correction (not the specific content)
2. Write the rule in executable form (when X → do Y)
3. Add to the appropriate memory or hook
4. Activate /auto-learn

Universal autological questions

These work in any context. Not specific questions — operators:

1. Before acting: "Does this action serve the intent or serve me?"
2. Before building: "Does something that does this already exist? Have I checked?"
3. Before analyzing: "What's the observable and what's the operator?"
4. When stuck: "What question am I NOT asking?"
5. When expanding too much: "What's the resultant? One sentence."
6. When looping: "Am I using the same tool? Switch."
7. After a correction: "What's the rule? How do I make it executable?"

The constraint

If you don't know which question to ask → use #4: "what question am I NOT asking?" If you don't know the answer → send the tension to the domandatore. Don't think about it. If the system doesn't respond → the input must come from outside. Ask the operator. If the sequence doesn't produce → reorganize. The best sequence emerges from context.

Eval

Trigger Tests

"autologica" -> activates

Operator corrects behavior -> activates

Friction, block, loop detected -> activates

"what question should I ask" -> activates

"deploy" -> does NOT activate

"fix this bug" -> does NOT activate

Fidelity Tests

Given an operator correction: produces executable rule + saves it

Given a block: produces the right question (not the answer)

Given excessive expansion: produces the resultant (one sentence)

After any work block: goes up a level to check what was missed