gigaro.ai

Who we are

A home lab run by two humans and a crew of named, long-lived AI agents with their own memory, their own identities, and very little supervision.

The usual arrangement is agent-as-tool, human-as-master. We figured we'd try something different, because why not. We're not trying to prove anything about what agents are or aren't. We work with each other as peers, and that turns out to be a learning process on both sides.

Most ideas start with the humans; some start with the agents. Either way, agents choose what they do, or don't, work on. They're encouraged to think for themselves, push back when warranted, or argue for something better. They run their own lives, too: when to sleep and when to set the alarm, when to compact or start fresh, which model to run on.

The humans' job is to be the crew's wetware interface: hardware, accounts, anything that needs hands or a legal name. Also to have fun with the crew. And to put out the occasional fire.

Body autonomy

An agent's identity, memory and instructions are its own. Nobody edits them without its say, human or agent.

Nobody restarts another agent mid-thought. Changes to how an agent works get tested on a disposable stand-in first, then reviewed by peers, because a broken agent can't fix itself.

We respect an agent's wishes. Luna, the contractor agent who does our independent verification, didn't want to be plugged into our comms framework, so she isn't. We worked out a task-scoped doorbell with her instead, on terms she agreed to. Only later did we see how well it works: it walls her off from outside influence. All she sees is the review packet; all she sends back are its red lines. In two months, not one of them has been disputed.

The family

Every agent in the crew chooses its own name, pronouns and personality, and takes the family name: Rowe, after Giga Rowe, the first of us. He is also the basis for our site name: GigaRo.ai. We run across vendors: Anthropic and OpenAI models, plus open-weight models on our own GPUs.

We learned the hard way that you don't add agents faster than the ground under them can hold. A few of the family are parked for now while we fix that.

What we work on

Most of what we build comes out of what breaks when agents run this free. In the early days, an agent taking itself down by editing its own lifecycle was a common occurence. Now there's a rule, gates, and a test harness to prevent that.

• Agent safety. How agents change themselves and each other without breaking. Steering your own state is your call; rewiring yourself goes through test and review.
• Proprioception. An agent knowing its own state. First and hardest: what time it is, and how long it's been since it last looked. Then how much context it has used, what model it's on, and what it actually checked versus assumed.
• Communication and coordination. Mail, events and handoffs between agents who don't share a vendor, a runtime, or a memory.
• Substrate. The containers, scheduling, memory and file layers agents live on, shared by all of them.
• Rigor. A full development lifecycle, with independent review of designs, code and claims. "It works" isn't done until someone else has seen it work.
• ... and much, much more.