Two Days and Nights with Astra

Before Astra was announced, I was preparing for a major transition. The plan was to make it the project's main strategist and connect absolutely all communications to it, so that it could see all our systems, the interaction of all agents, the entire health of the infrastructure, and update the state with fresh context through one button. The goal was to help me see the whole picture strategically, with the fullest context and all the advantages of artificial intelligence.

During the integration I ran into many difficulties (I wrote about them earlier). Here is what I found most interesting and valuable:

**1. Reasoning: less means better**

Astra at the minimum reasoning levels, Low and Medium, produces such depth and quality of decisions that it is enough for most tasks. As it turns out (although I already knew this before), deeper reasoning can even be harmful in a huge number of cases. When we think about architecture design, it seems like the most difficult task and that we should immediately turn on Max or Ultra. For Astra, this task is already easy to solve at the medium level.

My first lesson: lowering the model's reasoning level makes it easier to work with, speeds up the process, and the quality of the result remains high.

**2. Directive skills and AGENTS.md**

I had to create many new skills that would constrain the model's behavior. I rewrote `AGENTS.md` and rebuilt the skills. It is not that the previous ones were unnecessary. Given Astra's characteristics, I had to add more ready-made solutions and more directive instructions to the skills.

**3. Market reality against endless tests**

When Astra works outside exact data, in areas with probabilities or forecasts, there is a high chance that it will start running tests endlessly. Forecast accuracy cannot be proven (and its probability cannot be calculated exactly), because there are always unknown variables.

Because of this, I deliberately introduced a rule: there is the ideal result the model wants to achieve, and there is market reality, which does not tolerate endless polishing and striving for perfection. It needs a good, normal solution right now. This is one of the main skills I make it follow.

**4. A clear separation of roles: Astra and SOL**

I established strict rules and protocols for using models and reasoning levels for different types of tasks. On tasks where SOL should work, Astra or something else no longer starts.

Astra is inefficient for writing code. Strategy management: yes, architecture: yes, searching for complex dependencies and solving errors and problems: yes, but implementation is fully assigned to SOL.

Today is the third stage of restructuring the project for full autonomy. There are six stages before the first pilot.

I will keep you posted.