Aida — The Agent in the Space Between

Your words, made kind. Your deadlines, kept. Your name, always yours. Aida is a personal agent that carries workplace requests across the space between people — and hands the agreement back to humans.

Comment

Inspiration

It's 11:04 p.m. You've typed the message four times. "Hey, just checking in on—" Delete. "Sorry to bother you, but—" Delete. The work is one sentence. The worrying is twenty minutes. You'll send it tomorrow. Maybe.

Everyone has a version of this message. A nurse coming off a night shift, wondering if it's too early to ask about a swap. A junior designer who has waited three days for feedback from someone senior. The hard part is almost never the work itself — it's the tone, the timing, and the fear of becoming "that person." Chat tools deliver our words, then leave us alone with everything the words carry.

A request is one line of information — "the report, by Thursday, please" — but sending it costs far more than one line. So we soften it: "whenever you get a chance" — and the urgency, the information itself, quietly dies. Politeness kills the data, the uncomfortable messages get postponed, and entire books exist on how to write a reminder email — proof that this is a structural problem, not a personal skill issue.

Meanwhile, most workplace agents race in the opposite direction: produce more output, faster. But when no accountable human has reviewed that output, generation becomes verification debt for someone downstream.

We wanted a different kind of agent — one that doesn't do the work for people and doesn't speak instead of people, but takes care of the space where their work meets. So we gave each person their own agent, and the agents a shared protocol: coordination mechanics move between the agents, while commitments, judgment, and the relationship itself stay with the humans.

In Japanese, the word for "human being" is 人間: the character for person, plus the character for the space between. You don't become human alone; you become human between people. Aida (間) is the name of that space. We built an agent that lives there.

What it does

Aida is a two-sided agent for the small, awkward messages that hold teams together: the reminder, the nudge, the ask, the gentle no. It runs today as a working Slack pilot and a credential-free browser demo.

You talk to your Aida in your own words — tired, blunt, worried, whatever. Your raw text stays private. GPT-5.6 structures it into a Coordination Envelope of typed claims with explicit provenance: the existing commitment, any new request (with the requester's name on it), the desired deadline, and when an answer is needed. Nothing leaves your side until you approve the draft.

Your Aida then hands the envelope to the recipient's Aida — which never sees your raw private context. It delivers according to rules the recipient set: after focus hours, batched to a chosen time, or immediately only for genuinely critical cases the recipient pre-authorized. The recipient replies in plain words too — including a partial acceptance or a counterproposal like "N is not possible by Tuesday. Wednesday morning." — and approves how Aida phrases it back. An agreement exists only when both humans have explicitly confirmed it. Aida never accepts on anyone's behalf, never changes a deadline, and either side can choose Talk directly at any time.

Throughout, Aida keeps three voices apart: facts speak in the system's voice, human requests keep their human's name, and Aida's own assistance is always labeled as Aida's. When authority is unclear, deadlines conflict, or content is sensitive, Aida fails closed — it stops and asks the smallest question a human needs to decide. Every state transition is written to an audit log, attributed to a human, a personal Aida, or the system.

How we built it

First, an honest note about the word "we": this project was one human and Codex. Codex wrote all of the code. The human never read a line of it. The human's contribution was product judgment — the principles, the boundaries, the "no" list — delivered entirely as instructions written in Japanese.

From those instructions, Codex turned the thesis into a bounded architecture. The browser demo (React) and the Slack pilot (Bolt, Socket Mode) share a single TypeScript domain service instead of duplicating coordination logic. Zod schemas define the envelope, claim provenance, responses, approvals, audit events, and state transitions — and deterministic code validates every model proposal and owns every state change. The model interprets; only humans commit.

At runtime, GPT-5.6 is used in tiers: Terra handles routine contract extraction and interprets recipient responses; Sol takes ambiguous or contradictory cases and returns a structured escalation instead of choosing for the user; Luna is wired as an optional fast classification tier. The provider boundary supports both the OpenAI Responses API (with Structured Outputs) and the Codex CLI.

Challenges we ran into

The hardest problem was keeping the agent useful without letting it quietly become the decision-maker. Removing hostility while preserving deadlines exactly; reducing interpersonal pressure without reducing accountability; making coordination visible without making people observable — each of these forced authority, provenance, delivery, and agreement to be modeled as separate concepts rather than one blended "message." A related fight was personal-agent isolation: the sender's raw context must never enter the recipient's envelope, even when leaking it would make generation easier.

A second challenge was methodological: directing an agent to build an entire product from natural-language instructions in Japanese, without ever reading the code. Trust had to come from somewhere other than inspection — from stating intent clearly, watching the product's behavior, and iterating until the behavior matched the words. Which is, in the end, the same kind of trust Aida asks its users to place in each other: not in what you can see inside, but in what was explicitly agreed.

Accomplishments that we're proud of

A complete browser flow and a Slack pilot run on one deterministic coordination service. Human approval gates protect both initial delivery and final agreement. Claim-level provenance survives revisions, partial acceptance, and counterproposals. Sensitive cases, conflicting commitments, invalid schemas, and provider errors all fail closed. And the test suite — written by Codex — covers privacy boundaries, state transitions, Slack surfaces, persistence, time-zone behavior, and CLI safety.

What we learned

Agentic coordination turned out to be less about generating better messages and more about deciding who has the authority to do what. Typed boundaries and deterministic state transitions made the model more useful, not less — because they made its limits inspectable and testable.

We also learned what it feels like to be on the human side of the relationship Aida proposes: express intent in your own language, delegate execution entirely, and hold on to exactly one thing — the intent.

What's next

A recipient-owned calendar FreeBusy adapter that exposes only availability windows — never event titles, participants, locations, or descriptions. Coordination beyond two people, with the same isolation and approval boundaries intact. And controlled comparisons between direct messages and Aida-mediated ones — while keeping the same rule throughout: automate the process around human work, without turning the humans into performance data.

Most agents optimize what one person produces. Aida takes care of what happens between two.

Built With

Share this project:

Updates