The runtime, under the hood.
A short tour of the architectural bets that make Unify teammates work: where the slow brain lives, why memory is typed, what mid-flight steering actually means, and how voice fits in. If you'd rather see it in action, hop on a call.
A persistent reasoning loop, above the tool-caller.
Most agent frameworks have one loop: model picks a tool, tool runs, result feeds the next decision. Unify puts a second, persistent loop above that — the ConversationManager — which stays present with the user across every medium, keeps thinking while dispatched work is in flight, and supervises the inner tool-calling loop rather than running as that loop itself.
This is the same shape that Thinking Machines' interaction-models post articulated. We arrived at it at the harness level. When interaction-native models ship publicly, they'll replace this split end-to-end.
Live calls are first-class, not a plugin.
Browser, phone, Zoom, Meet, Teams. Sub-second latency, interruption-handling, telephony-aware. Production-grade voice is the part most agents bolt on; in Unify it's at the agent layer — the same loop that handles a Slack message handles a live call, with the same memory and the same primitives.
Contacts, knowledge, tasks — each in its own table.
Memory is not transcript-soup or markdown files you maintain by hand. Every conversation distills into typed, queryable tables: contacts you've talked about, knowledge you've taught, tasks you've assigned, files you've named.
By month two, you stop telling the teammate which numbers, which tone, who reads the recap — they already know. The skill library consults memory before reaching for raw tools.
Mid-flight correction is a first-class signal.
Every public manager method returns the same type — a SteerableToolHandle with ask, interject, pause, resume, stop. Handles nest: a correction the user makes in chat propagates down through whatever dispatched action is currently running.
Mid-flight steering isn't an opportunistic abort; it's the way you steer the work. Pause a long-running PR draft, redirect it, watch it resume — without restarting.
Every teammate is a real workspace account.
Each teammate gets a real desktop — browser, files, terminal — with scoped OAuth into the apps you connect. Admins control access from one screen, every action is audited, every integration is one-click revocable. Same model your existing team already uses.
Stable workflows promote themselves.
After enough successful runs, a workflow promotes itself into a personal skill — executable Python plus the procedural how-to prose to use it. Every future session consults the skill library before reaching for raw tools.
Recurring jobs ("every Monday at 9, digest this week's GitHub notifications") and event triggers ("ping me whenever CI on main fails") are first-class natural-language primitives, fired by the same Actor that handles live work — not cron expressions or webhook YAML you hand-maintain.
Three sibling repos, all on GitHub.
The core runtime, the Python SDK, the LLM client, and the persistence backend are MIT-licensed. Install once, and Unity lives on your laptop, accumulating state across every session. The hosted product at console.unify.ai wraps this in a commercial UI — multi-tenant identity, hosted telephony, billing.
Pick the workflow that's been eating your week.
Starter credits, no card. You'll have a teammate running real work before the end of the call.