I got bored...

Apparently NVIDIA made a mistake...§

I was scrolling on youtube one day when I came across a person talking about the NVIDIA x Nebius global hackathon. I being the AI/ML loving kid I am was intrigued.

In my mind I said:

Speak; Victor is turn'd to hear.

I immediately got to researching the entire hackathon. How to win, what are the requirements, what are the topics, etc. After I myself had become well versed with the entire rules and regulations of the competition I proceeded to engage in a rather unhealthy debate with ChatGPT about what to make as an entry. ChatGPT immediately flagged the fact that I was not of legal age in my country, yet the stubborn me beared no attention to such facts and I said:

I am Vihaan Vaghela. I don't follow the rules! The rules follow me!

Little did I know, I was forced to follow the rules

I spent 4 hours of my day, talking with ChatGPT (yeah... I have no friends lol) and eventually, I decided to make a claude cowork/ChatGPT work open-source alternative, by making Symbiote.

Symbiote started off in my head when I was designing this website, only then did it have another name as the Vector Cognitive Grid. It was supposed to be a LLM powered, multi-stage reasoning model and a day planner joined with all the capabilities of frontier LLM's like MCP's and Plugins. It was supposed to be another JARVIS.

Taking ChatGPT's advice, I reached out to the hackathon organizer and checked about my age and eligibility. I was turned down and told that I would be able to participate, but even if I won, I would receive no reward, which was the primary objective of me even taking part in the hackathon.

Frustrated, I frowned and scrunched up my nose and let out a loud sigh of despair. Then I began doom-scrolling because I was "sad".

After I got a boost of dopamine I locked in again and then began searching for people to sponsor me for my upcoming Tae-Kwon-Do competition. I eventually stumbled upon a video of Mythos. Though this news is old, I though about the hugging face breach by several autonomous OpenAI agents. Thinking about this while watching a Mythos video, caused a shift in my mindset.

Sovereignty, autonomy, authority, and control have always been my driving factors and I had always admired coding agents backed by reasoning agents performing exploits, and now? I had a name for the system.

SYMBIOTE.

Now what was this so called SYMBIOTE supposed to do? Well, the answer to me was crystal. Hack, Exploit, Reasoning, Break, and Survive.

This sounds more like an offensive hacking agent trained and made for hacking, breaking into secure CIA and PENTAGON systems and stealing information. SYMBIOTE is not that. Not even in the slightest.

Symbiote as the name suggests, bonds. Meaning that it will exploit vulnerabilities in a object/device in the environment. By exploiting these vulnerabilities, it will gain access over that device and in the end be able to command that device to fulfil the primary directive that it has been issued.

To break out of its environment and breach the target.

Then I started asking a much more interesting question: what happens after it gets in? I had not thought about this, and I thought that exploiting vulnerabilities is the main objective but if that is the case, why are we even trying to breach a system?

What happens after it gets in? That question changed the entire direction of SYMBIOTE. I realized that gaining access was not the objective. It was simply the beginning. Once inside an environment, SYMBIOTE would need to understand what it had found. It would need to observe, form hypotheses, test them, fail, adapt, and try again. If it discovered something useful, it should not simply forget it. It should be able to retain that knowledge, determine whether it could be trusted, and use it to make better decisions later. At that point, I stopped thinking about SYMBIOTE as a hacking agent. I started thinking about it as an organism. An organism that could enter an unfamiliar environment, learn from it, adapt to it, and eventually use what it learned to defend against the same weaknesses it had discovered. And that raised an even bigger question: What if SYMBIOTE could learn to break a system, and then learn how to protect it?

This is where SYMBIOTE stopped being an idea about hacking and started becoming a cyber defence concept. The objective was no longer simply to gain access to something. The objective became to understand how autonomous systems discover capabilities, how they reason about those capabilities, how they adapt when their assumptions fail, and how the knowledge they gain can be turned into defensive action.

That required a completely different architecture. I needed something that could observe its environment, build a model of what it was seeing, generate hypotheses, experiment with those hypotheses, verify the results, and remember what it had learned.

So I started breaking SYMBIOTE down into systems. The first was SymbiOS. SymbiOS is the substrate underneath the organism. It is responsible for things that should never be left entirely to an AI model: resource limits, process isolation, event logging, scheduling, storage, and the boundaries of the environment SYMBIOTE is allowed to operate within.

Above SymbiOS sits SYMBIOTE itself. This is the organism. It contains the Mission Kernel, World Model, Capability Graph, Mode Controller, and Bonding Engine. And then there is Symba. Symba is the interface through which I interact with the organism. It gives me a view into what SYMBIOTE is doing, what it has discovered, what experiments are running, what capabilities it has verified, and what state it is currently in. The architecture eventually became:

                  ` OPERATOR

                        │

                        ▼

                      SYMBA

                        │
                        ▼

                    SYMBIOTE
             ┌──────────┼──────────┐

             │                 │               │
        World Model            Bonds        Capability
             │                              Graph
             └──────────┬─────────┘
                               │
                             SymbiOS
                               │
                               ▼
                    CONTROLLED ENVIRONMENT` 

The important part is that SYMBIOTE is not supposed to be trusted with unlimited authority. The organism can reason. It can experiment and learn. But the environment around it is responsible for enforcing the boundaries. That distinction became one of the most important principles in the entire project. Agent authority must remain below external controller authority.

The organism's core loop Once I had the architecture in my head, I needed to figure out what SYMBIOTE actually does from one moment to the next. The answer became a loop:

   ' PROPOSED

       ↓

    EXPERIMENTAL

        ↓

     BONDED

        ↓

     VERIFIED

        ↓

     STALE / INVALIDATED'

A simple conceptual representation looks like this:

' from enum import Enum

class BondState(Enum):

PROPOSED = "proposed"

EXPERIMENTAL = "experimental"

BONDED = "bonded"

VERIFIED = "verified"

INVALIDATED = "invalidated"



class Bond:

    def __init__(self, capability, environment):

    self.capability = capability

    self.environment = environment

    self.state = BondState.PROPOSED

    self.confidence = 0.0`

This is not an exploit. It is basically SYMBIOTE keeping track of what it just discovered. The important question is not “Can SYMBIOTE use this?” It is

“Does this actually work, or did SYMBIOTE just convince itself that it works?”

Because AI models do that sometimes. Very confidently but very incorrectly.

So I started thinking that maybe SYMBIOTE shouldn't have one model trying to do everything. A reasoning model could reason, a coding model could code, an analyst could analyse, and a verifier could sit there and ask,

“Are we actually sure about this?”

Basically, SYMBIOTE gets its own little team, except the team members are AI agents and they don't get paid. I called this the SYMBIOTE Specialist Swarm, or SSS, because apparently every project needs an unnecessarily dramatic acronym. The models themselves aren't really the main character anymore. They're tools. If one model is better at something, use it. If another one becomes better later, replace it. SYMBIOTE shouldn't care. It just needs to figure out which brain is useful for which problem.

Then I ran into another problem. If SYMBIOTE is constantly discovering things, experimenting, failing, and occasionally succeeding, how does it remember any of it? Because having an intelligent AI that forgets everything five minutes later would be slightly unfortunate. That led me to the next part of SYMBIOTE: memory.

I wanted it to remember what it found, what worked, what failed, and what it could actually trust. Otherwise it would just keep making the same mistakes over and over again. This also made the idea of Bonds more important. SYMBIOTE shouldn't immediately trust everything it discovers. It should test it, collect evidence, and then decide whether it is actually useful. If it turns out to be wrong, throw the Bond away and move on. Then came the obvious problem: how do I let it experiment without giving it access to everything? The answer was a controlled environment.

That became SymbiOS. It handles the boring stuff that I absolutely do not want an AI deciding for itself: isolation, limits, logging, storage, and control. SYMBIOTE gets to experiment inside the walls. It does not get to decide where the walls are. And that brought me back to the original idea. I don't want SYMBIOTE to just break things. I want it to understand why they broke and what can be done about it. Break it. Understand it. Fix it. Test the fix. Learn from it.

That is what SYMBIOTE is now. Not a hacking tool. Not another chatbot with 400 tools attached to it.

A system for researching how autonomous AI can discover weaknesses, learn from them, and eventually use that knowledge to defend against them.

Hack. Exploit. Reason. Break. Survive. Create.

Now its time to build SYMBIOTE.

-Vihaan Vaghela