What we have been building did not start with the idea of giving an agent more autonomy.
It started earlier, when we began strengthening the way we work as a team.
We started with the process
We made our processes more explicit, standardizing how we relate to the work, how we leave evidence, how we connect a story to a change, how we review, how we follow up and how we understand the real state of a project.
Many of those practices already existed, but they were distributed across people, tools and different ways of working. By making them more consistent and observable, we also began to reduce the ambiguity of the system.
Autonomy as a consequence
That changed our relationship with AI.
At first, agents required a lot of supervision, specific instructions and a constant transfer of context. But as the environment became more structured, the kind of relationship we could have with them began to change as well.
The agent no longer had to rebuild everything from scratch. It could better understand where the project stood, which rules to follow, which information to consult, which actions were valid and what evidence it had to leave behind.
Autonomy, then, was not the starting point. It was a consequence of having strengthened the system around the agent.
Information as a continuous architecture
As we refined these processes, we also began to work differently with information.
We stopped seeing it only as something a person looks up when they need it, and started treating it as part of a continuous architecture.
The repository, the tickets, the PRs, the comments, the reports and the decisions are no longer just isolated records. They begin to form a living representation of the state of the project.
On top of that representation we can build monitors, routines, reviews and agents that continuously observe what is happening. The system can detect changes, check consistency, identify blockers, generate reports or react to certain events without depending on someone explaining the whole context again.
A persistent environment
This brings us to a second stage: consolidating that operating knowledge inside a persistent environment that keeps the project up to date, along with the metastructure we have been building around it.
That environment does not aim to become "the main agent". Its job is to maintain continuity. That is where the rules live, the context, the processes, the observation mechanisms, the traceability and the ways in which an agent should relate to the project.
From there, different tools can connect on the same base. It can be a terminal, Cursor, another IDE, another harness or various specialized agents. The interface can change and the model can change, but the project keeps its structure and its way of operating.
A common interface
That is the point we want to consolidate.
We do not want every person to have to learn how the whole agentic system works on the inside in order to use it. We want to encapsulate that operating knowledge and project it as a common interface on which humans and agents can work.
Instead of constantly transferring the knowledge of how to operate the system, we want that knowledge to become part of the system itself.
First the process, then autonomy
That is our approach to AI integration: first strengthen the process, then gain autonomy, and finally turn that learning into a continuous architecture that can be maintained, observed, audited and evolved.
