One question I'm asked all the time is: How does NonBioS work?

NonBioS is an Autonomous Coder that helps developers write, debug, and analyze code more efficiently. While it has always been challenging to explain its functionality, I had an "aha" moment while watching a friend show off his recently acquired Tesla with Full Self-Driving (FSD) capability. That's when it struck me – maybe it's not so hard to explain after all.

NonBioS is to coding what Tesla is to driving. Both are autonomous systems that aren't completely autonomous yet, but at their core, the technologies share remarkable similarities.

Let me break it down.

The Three Fundamental Levers of Autonomy

At the core of any autonomous agent, there are three fundamental levers that work together to create an effective system:

1. Strategy

2. Guardrails

3. Guidance

For NonBioS specifically, autonomy is measured by its ability to successfully complete a task. This could be implementing a feature in a codebase, building a proof of concept for a new product, debugging existing software, or analyzing a GitHub repository for insights. Perfect AI autonomy means that NonBioS would complete the task 100% of the time, with 100% satisfaction from its human operator. While we still have work to do to achieve this goal, we're closer than you might think.

If you've driven a Tesla with FSD, you'll easily relate to how these levers work in practice.

Strategy

Strategy is the high-level plan that the AI creates to complete a task. Think of it like entering start and end locations in Google Maps to find the optimal route. This already works exceptionally well for cars, almost 100% of the time. Surprisingly, it also works remarkably well for NonBioS. Given an objective, such as building a mobile app, it can break down the goal into smaller, manageable steps to reach the destination.

Guardrails

Guardrails are systemic protections that prevent catastrophic failures from which the agent might not recover. For a Tesla, this includes features like lane assist and automatic braking to prevent collisions. Guardrails can also activate as preventive measures – for example, a Tesla might slow down in a school zone even without immediate danger present.

For NonBioS, guardrails are critical in ensuring alignment. As a beta user, you might notice guardrail notifications pop-up while NonBioS works. These are systemic guidelines directing NonBioS to execute tasks in specific ways. For now, you can safely ignore these as they're primarily addressed to NonBioS itself. While we might suppress these notifications in the future, we currently maintain them to help users understand why NonBioS makes certain decisions.

Guidance

Guidance represents human input in both Tesla and NonBioS systems. While strategy and guardrails are essential, human guidance remains critical for Tesla to navigate from point A to point B. As the car's autonomy increases, the need for human guidance will progressively decrease. NonBioS follows a similar pattern – if you notice it heading down the wrong path, you can take control and correct its course.

However, the approach to guidance differs significantly between Tesla and NonBioS. A Tesla operates in a high-risk environment where mistakes could be fatal. Consequently, Tesla's guidance system prioritizes caution – the driver must remain engaged and ready to take control at a moment's notice.

In contrast, NonBioS employs a more permissive guidance approach. This is possible because NonBioS primarily writes code backed by version control systems (like Git). If it makes a mistake, you can simply restore from source control and restart execution. NonBioS continues its task until you decide to intervene. While you can take control just as you would in a Tesla, our beta users rarely find this necessary.

The most significant takeaway about NonBioS's functionality – similar to Tesla's FSD – is that its current autonomous capabilities already far exceed anything you've used before. It represents a massive cognitive improvement over writing code entirely by yourself. You often don't need to "think through" implementing smaller features; simply reviewing the output is sufficient. Even for larger features, you can focus on system-level perspectives rather than getting bogged down in implementation details.