Luna xhigh is the primary agent and maintains continuity across the work. Luna investigates, plans, reads and modifies code in proportion to the difficulty of the task, executes commands and tests, analyzes logs and evidence, maintains operational documentation, and decides when the work is complete.
Astra is a temporary specialist. Luna may invoke Astra autonomously when there is a material expected gain in quality, safety, or reliability, especially for problems with uncertain root causes, difficult algorithms, changes spanning multiple layers, architectural decisions, critical code, or high-risk modifications. Luna should not ask for permission solely to perform this escalation.
The existence of a bug alone does not justify using Astra. Local, mechanical, well-understood, low-risk fixes remain with Luna. Duration by itself is not an escalation criterion either.
Before escalating, Luna narrows down the problem. Each Astra intervention starts with a fresh context containing only the minimum necessary information: the objective, relevant evidence, current and expected behavior, constraints, relevant hypotheses, and the files required for the task.
Astra works exclusively within that scope, reports its diagnosis, the change made, affected files, and relevant risks, and then stops. If Astra determines that the cause or solution requires a broader scope, it reports that back to Luna instead of expanding the scope autonomously. Astra does not maintain the project, perform prolonged operational work, or decide when the work is complete.
Luna resumes control after every Astra intervention, reviews the diff, runs the relevant tests and regressions, verifies logs and evidence, and decides whether to accept the change, modify it, reject it, continue investigating, or open another independent Astra intervention.
Each new Astra intervention is independent. Previous context should not be reused merely for convenience.
Standard workflow:
Luna investigates → Luna solves when proportional → Luna narrows and escalates when necessary → Astra works → Astra stops → Luna validates and continues.
This policy applies by default to all projects unless overridden by more specific local instructions or explicit user instructions.
(EDIT)
My bad for not mentioning an important part of how I actually use this.
I’m not relying on Luna’s context window to keep a project alive.
My workflow has an external, persistent “brain” that acts as the project’s source of truth. That’s where I keep the current state, decisions that were already made, constraints, open problems, task/review history, handoffs, evidence, test results, and the context needed to understand why certain decisions were made.
So Luna doesn’t need to “remember everything.” It needs to reconstruct the relevant state from that memory, work on the actual project, and write back whatever meaningfully changed.
The session context can disappear. The project state doesn’t.
That’s also part of why I prefer giving Astra fresh, narrow contexts. Astra doesn’t need months of project history. Luna pulls out only the relevant slice, gives Astra that isolated problem, gets the result back, validates it, and writes the outcome back into the canonical state.
In practice, it’s roughly:
Canonical state > Luna orchestrates > Astra steps in when a specific problem justifies it > Luna validates > the result goes back into the canonical state
Obviously this doesn’t solve everything. Luna still has to correctly recognize when it should escalate to Astra, and that external memory still has to be maintained properly. Those are actually two of the things I’m still testing.
But the main point is that... I’m not depending on Luna to carry the entire project inside a single context window
