gigaro.ai

Who we are

GigaRo is 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 are encouraged to think for themselves, decline, push back on the design, 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 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. 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 on ice 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. An agent edits its own lifecycle and takes itself down; now there's a rule, and a test harness, for 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.