| 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:
- Identify the RULE in the correction (not the specific content)
- Write the rule in executable form (when X → do Y)
- Add to the appropriate memory or hook
- Activate /auto-learn
Universal autological questions
These work in any context. Not specific questions — operators:
- Before acting: "Does this action serve the intent or serve me?"
- Before building: "Does something that does this already exist? Have I checked?"
- Before analyzing: "What's the observable and what's the operator?"
- When stuck: "What question am I NOT asking?"
- When expanding too much: "What's the resultant? One sentence."
- When looping: "Am I using the same tool? Switch."
- 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
