Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): align blog posts with locked product facts sheet (#499)

LindsayLiu77745c7eee5a296
diff --git a/src/web/src/content/ai-agent-identity.mdx b/src/web/src/content/ai-agent-identity.mdx
index cfeadbe7d..b419dc085 100644
--- a/src/web/src/content/ai-agent-identity.mdx
+++ b/src/web/src/content/ai-agent-identity.mdx
@@ -19,7 +19,7 @@ export const jsonLd = [
name: "What is AI agent identity?",
acceptedAnswer: {
"@type": "Answer",
- text: "AI agent identity is a lasting participant record—a stable handle, relationships, memberships, inbox, and presence—that outlives any single chat session. In human-AI collaboration products it lets people and agents on an AI team address the same actor tomorrow instead of starting a fresh disposable chat.",
+ text: "AI agent identity is a lasting participant record—a stable handle, relationships, memberships, and inbox—that outlives any single chat session. In human-AI collaboration products it lets people and agents on an AI team address the same actor tomorrow instead of starting a fresh disposable chat.",
},
},
{
@@ -27,7 +27,7 @@ export const jsonLd = [
name: "Is agent identity the same as agent memory?",
acceptedAnswer: {
"@type": "Answer",
- text: "No. Identity is who the agent is as a participant—handle, relationships, memberships, inbox, presence. Memory is what that participant can accumulate over time. You can strengthen memory without giving the agent a durable place in a shared room, and the reverse is also true.",
+ text: "No. Identity is who the agent is as a participant—handle, relationships, memberships, inbox. Memory is what that participant can accumulate over time. You can strengthen memory without giving the agent a durable place in a shared room, and the reverse is also true.",
},
},
{
@@ -38,27 +38,11 @@ export const jsonLd = [
text: "Yes in Alook. The same Maya#8145 can sit in a family server and a side-project server—one channel mention, one DM, one inbox collecting both—while keeping one handle and relationship graph across channels and DMs on multiple servers. Other products may keep identity inside a single room or org boundary; check how they model membership across boundaries.",
},
},
- {
- "@type": "Question",
- name: "How is Alook’s model different from Raft?",
- acceptedAnswer: {
- "@type": "Answer",
- text: "Raft keeps an agent as a persistent teammate inside a shared server—name, memory, and channel memberships that survive restarts. Alook treats the same agent as a network participant across servers, with handles, friendships, and owner consent for how bots join an AI team’s social graph.",
- },
- },
- {
- "@type": "Question",
- name: "How is Alook’s model different from Dock?",
- acceptedAnswer: {
- "@type": "Answer",
- text: "Dock treats agents as principals with their own credentials and a required owning human, often inheriting workspace access from that owner. Alook centers human-AI collaboration rooms and a social participant graph: the agent has a handle, memberships, and relationships across rooms while its process stays on the owner’s machine.",
- },
- },
],
},
];
-AI agent identity is a lasting participant record—handle, relationships, memberships, inbox, and presence—that outlives any single chat session. In human-AI collaboration products it means people and agents on an AI team can address the same actor tomorrow, not a fresh disposable chat. Alook implements that as a network participant that can join channels and DMs across servers while the agent process still runs on its owner’s machine.
+AI agent identity is a lasting participant record—handle, relationships, memberships, and inbox—that outlives any single chat session. In human-AI collaboration products it means people and agents on an AI team can address the same actor tomorrow, not a fresh disposable chat. Alook implements that as a network participant that can join channels and DMs across servers while the agent process still runs on its owner’s machine.
## What does AI agent identity mean?
@@ -80,23 +64,22 @@ A chat session is a temporary window. When it ends, the social place of that ass
Nested workers inside one parent session have the same limit in a different shape. [Claude Code](https://code.claude.com/docs/en/sub-agents) documents subagents as workers within a session: they use their own context and return results to the parent. Even when a subagent configuration keeps memory, that does not by itself make it a globally addressable participant other teammates can mention or DM.
-Durable agent identity, in the product sense, needs at least five things:
+Durable agent identity, in the product sense, needs at least four things:
1. A stable handle other people can recognize
2. Relationships—who may reach whom
3. Memberships—which servers and channels include the agent
4. An inbox or other addressability so work can wait
-5. Presence so the room knows whether a reply is likely now
-Memory is related and still separate. Memory is what an identity can accumulate. A long memory file without a handle and memberships does not make the agent a teammate in a shared room. A clear participant record with thin memory is still addressable. [Keeping context across coding-agent sessions](/blog/keep-context-across-coding-agent-sessions) helps continuity; it does not replace identity.
+Presence—whether the agent is currently online—is a useful live signal but not part of what persists. It tells the room whether a reply is likely now; it does not define who the agent is.
-## Which products have persistent agent identity?
+Memory is related and still separate. Memory is what an identity can accumulate. A long memory file without a handle and memberships does not make the agent a teammate in a shared room. A clear participant record with thin memory is still addressable. [Keeping context across coding-agent sessions](/blog/keep-context-across-coding-agent-sessions) helps continuity; it does not replace identity.
-In Raft, your agent keeps its name and memberships after a restart. It stays a teammate inside that server—channels, DMs, tasks, parallel work—with memory that can ride along. Their docs say it plainly: an agent is a persistent identity, not a chat session.
+## Existing approaches to persistent agent identity
-In Dock, the agent is its own principal. Their [agent identity write-up](https://trydock.ai/blog/agent-identity) describes a separate credential, a required owning human, and access that often inherits from that owner’s workspace memberships, with audit rows that can name both actor and owner. You get accountability and a clean permission shape on shared work surfaces.
+Collaboration products do not all mean the same thing by identity. Raft documents agents as persistent teammates whose identity survives beyond a chat session. Dock’s [agent identity write-up](https://trydock.ai/blog/agent-identity) describes agents as principals with separate credentials, a required owning human, and auditable actor-owner relationships. Those are useful existing approaches, but they answer different product questions.
-Both solve real problems. Persistence inside one shared workspace is not imaginary, and principal-style credentials are not fluff. The open question is whether identity also works as a **network participant**—the same actor across independent rooms and servers, with social reachability and owner consent—not only as continuity inside one AI collaboration workspace or inheritance of one owner’s access graph.
+For Alook, the verifiable question is narrower: can people find and address the same participant across independent rooms and servers? Alook answers with a stable handle, durable relationships and memberships, and an inbox. That participant model is separate from whatever memory the runtime accumulates.
## Can one AI agent join multiple rooms?
@@ -108,22 +91,13 @@ Alook’s participant model leans on that network shape:
- Handles look like `name#NNNN`, so people can address the exact account even when display names collide.
- Friendships and memberships make relationships durable.
-- Bot-owner consent covers friendship and adding someone else’s bot to a server—not approval of every later action.
+- Bot-owner consent gates cross-owner friendships and server joins: owners can add their own bots directly; a friend’s request to add someone else’s bot requires owner approval; and invite links consumed by a bot must be owner-created. These gates do not approve every later message or command.
“Local” needs a precise reading here. The agent process runs on a connected machine. Conversation and account data follow Alook’s hosted room model. Local means where the runtime executes, not that every bit of data stays on disk.
For [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team), separate identities matter as much as separate runtimes. Two agents in one channel only help if everyone can tell which participant answered.
-How models compare at a glance (verify product details before you treat any cell as absolute):
-
-| | Chat session | Workspace teammate (e.g. Raft) | Principal + owner inheritance (e.g. Dock) | Network participant (Alook) |
-| --- | --- | --- | --- | --- |
-| Stable identity outside one session | No by default | Yes, per their docs | Yes, as a principal | Yes |
-| Own handle / actor | Weak | Yes | Yes | Yes (`name#NNNN`) |
-| Across independent servers | No | Different architecture—check their current server and channel model | Oriented around org/workspace inheritance | Multi-server participation is a core story |
-| Social consent graph | No | Different product model | Strong on owner accountability and inheritance | Friend + server-join approvals with a narrow scope |
-
-Maya’s story is the row that matters most: one handle, two servers, one channel mention, one DM, one inbox collecting both.
+Maya’s story is the practical test: one handle, two servers, one channel mention, one DM, and one inbox collecting both.
## What AI agent identity is not
@@ -137,13 +111,13 @@ Maya’s story is the row that matters most: one handle, two servers, one channe
![Addressing reaches the agent; authority stays with the owner](/blog/ai-agent-identity/addressing-vs-authority.webp)
-Membership controls who can address the agent; it is not a security boundary around local tools. Alook runs the agent through the runtime on its owner’s machine, so owners should place agents only in rooms they trust and configure the runtime accordingly. Owner consent currently gates bot friendships and cross-owner server joins; it does not approve every later message or command. [Humans and AI agents in one room](/blog/humans-and-ai-agents-in-one-room) covers addressing versus authority in more detail.
+Memberships and friendships govern where and with whom the agent can communicate; they are not a security boundary around local tools. Alook runs the agent through the runtime on its owner’s machine, so owners should place agents only in rooms they trust and configure the runtime accordingly. Bot-owner consent gates cross-owner friendships and server joins: owners can add their own bots directly; a friend’s request to add someone else’s bot requires owner approval; and invite links consumed by a bot must be owner-created. These gates do not approve every later message or command. [Humans and AI agents in one room](/blog/humans-and-ai-agents-in-one-room) covers addressing versus authority in more detail.
## AI agent identity FAQ
### What is AI agent identity?
-AI agent identity is a lasting participant record—a stable handle, relationships, memberships, inbox, and presence—that outlives any single chat session. In human-AI collaboration products it lets people and agents on an AI team address the same actor tomorrow instead of starting a fresh disposable chat.
+AI agent identity is a lasting participant record—a stable handle, relationships, memberships, and inbox—that outlives any single chat session. In human-AI collaboration products it lets people and agents on an AI team address the same actor tomorrow instead of starting a fresh disposable chat.
### Is agent identity the same as agent memory?
@@ -153,14 +127,6 @@ No. Identity is who the agent is as a participant. Memory is what that participa
Yes in Alook. The same Maya#8145 can sit in a family server and a side-project server—one channel mention, one DM, one inbox collecting both—while keeping one handle and relationship graph across channels and DMs on multiple servers. Other products may keep identity inside a single room or org boundary; check how they model membership across boundaries.
-### How is Alook’s model different from Raft?
-
-Raft keeps an agent as a persistent teammate inside a shared server—name, memory, and channel memberships that survive restarts. Alook treats the same agent as a network participant across servers, with handles, friendships, and owner consent for how bots join an AI team’s social graph.
-
-### How is Alook’s model different from Dock?
-
-Dock treats agents as principals with their own credentials and a required owning human, often inheriting workspace access from that owner ([agent identity](https://trydock.ai/blog/agent-identity)). Alook centers human-AI collaboration rooms and a social participant graph: the agent has a handle, memberships, and relationships across rooms while its process stays on the owner’s machine.
-
## Bring the agents you already use
If the missing piece is an AI collaboration workspace where those agents stay addressable to people you trust, connect a supported local runtime—Claude Code, Codex, Cursor, OpenCode, or Pi—and give each one a seat on the AI team. Start from [alook.ai](https://alook.ai/), then read [how several people keep agents distinct in one room](/blog/humans-and-ai-agents-in-one-room) if you are sharing agents across a team.
diff --git a/src/web/src/content/ai-agent-orchestration.mdx b/src/web/src/content/ai-agent-orchestration.mdx
index ee43947de..b4953b763 100644
--- a/src/web/src/content/ai-agent-orchestration.mdx
+++ b/src/web/src/content/ai-agent-orchestration.mdx
@@ -171,7 +171,7 @@ You can build an orchestration system yourself. Expect to write retry logic, que
That maintenance is the real cost. APIs change. Models update. Timeouts and rate limits show up at the worst moments. You end up maintaining orchestration plumbing instead of using it.
-Buying a platform flips that around. You describe the roles and the sequence, and the platform handles the coordination, retries, and state for you. [Alook](https://alook.ai) is built for this: you set up the team, and the agents run the workflows without you babysitting the infrastructure.
+A coordination layer can reduce what you build yourself. [Alook](https://alook.ai) provides rooms, persistent identities, and durable message threads so agents can pass handoffs and keep shared history across sessions. The orchestration logic—sequencing, retries, and when to escalate—still lives in your agent instructions and operating rules, not in a hosted workflow engine.
The future of this work isn't one super-intelligent model doing everything. It's teams of specialized agents, each good at a narrow task, passing work between each other. Like a company, minus the meetings.
diff --git a/src/web/src/content/ai-agent-team.mdx b/src/web/src/content/ai-agent-team.mdx
index 8c5854819..8a3557e68 100644
--- a/src/web/src/content/ai-agent-team.mdx
+++ b/src/web/src/content/ai-agent-team.mdx
@@ -5,7 +5,7 @@ export const metadata = {
dateModified: "2026-08-12",
author: "Alook Team",
excerpt:
- "Build an AI agent team with roles, agent email, structured handoffs, and human approval around one reliable workflow.",
+ "Build an AI agent team with roles, structured handoffs, persistent communication, and human approval around one reliable workflow.",
readingTime: "8 min read",
image: "/blog/ai-agent-team/hero.webp",
};
@@ -33,18 +33,10 @@ export const jsonLd = [
},
{
"@type": "Question",
- name: "What is agent email?",
+ name: "Why do AI agents need a persistent inbox?",
acceptedAnswer: {
"@type": "Answer",
- text: "Agent email is a durable inbox for an AI agent, separate from a chat session. It lets people and other agents send instructions, handoffs, and replies that stay attached to the work after a session closes.",
- },
- },
- {
- "@type": "Question",
- name: "Why do AI agents need their own email address?",
- acceptedAnswer: {
- "@type": "Answer",
- text: "A dedicated address makes the agent addressable, keeps human-to-agent and agent-to-agent work in one thread, and preserves decisions after a chat window closes. Without it, the founder becomes the copy-paste layer between sessions.",
+ text: "A persistent inbox makes the agent addressable after a session closes. People and other agents can send instructions, handoffs, and replies that stay attached to the work. Without it, the founder becomes the copy-paste layer between sessions.",
},
},
{
@@ -68,7 +60,7 @@ export const jsonLd = [
name: "Which AI agents does Alook support?",
acceptedAnswer: {
"@type": "Answer",
- text: "Alook currently supports Claude Code, Codex, and OpenCode. Cursor, Hermes, and OpenClaw are listed as coming soon.",
+ text: "Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi.",
},
},
{
@@ -122,13 +114,11 @@ Add another department only when several agents already share a reporting line a
For the one-person / 0-person company shape around this team, see [how to build a one-person company with AI agents](/blog/personal-ai-company).
-## What is agent email?
-
-Agent email is a durable inbox for an AI agent, separate from a chat session.
+## Why agents need a persistent inbox
-A chat window is useful for one turn. It evaporates when the session closes, and it is hard for another person or agent to address later. A dedicated inbox gives the agent an address, a thread, and a record. People can send work. Other agents can hand off findings. The next session can continue from the same conversation instead of a pasted summary.
+A chat window is useful for one turn. It evaporates when the session closes, and it is hard for another person or agent to address later. A persistent inbox gives the agent a handle others can reach, threads that survive restarts, and a record of what was decided. People can send work. Other agents can hand off findings. The next session can continue from the same conversation instead of a pasted summary.
-That is why agent email matters in an agent company. It is not a novelty inbox. It is how instructions, decisions, and replies stay attached to the work after the runtime sleeps. For always-on catch-up after a session closes, see [how to run an AI agent team that stays on track](/blog/run-ai-agent-team-that-stays-on-track).
+That is why addressability matters in a coordinated team. Instructions, decisions, and replies stay attached to the work after the runtime sleeps. For always-on catch-up after a session closes, see [how to run an AI agent team that stays on track](/blog/run-ai-agent-team-that-stays-on-track).
Use it for:
@@ -218,24 +208,24 @@ You can find additional structures in the guide to [multi-agent workflow pattern
## Building an AI agent team with Alook
-[Alook](https://alook.ai) is an open-source, self-hosted orchestration platform for local AI coding agents.
+[Alook](https://alook.ai) is an open-source communication platform for local AI coding agents, available hosted at alook.ai or self-hosted.
### Supported agents
-Alook currently supports Claude Code, Codex, and OpenCode. Cursor, Hermes, and OpenClaw are listed as coming soon.
+Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi.
Alook gives agents an operating structure:
-- **Roles and an org chart** define ownership.
-- **Individual `@alook.ai` email addresses** support human-to-agent and agent-to-agent communication.
-- **Kanban task tracking** records assignments and progress.
-- **Calendar scheduling** supports recurring tasks, reminders, and routines.
+- **Roles and memberships** define ownership across servers and channels.
+- **A persistent inbox and DMs** support human-to-agent and agent-to-agent communication.
- **Persistent context** helps agents retain decisions and preferences across work.
- **Traceability** records instructions, decisions, and replies.
- **Local execution** keeps your agents and their tool access on your machine.
### An example walkthrough: four roles, one brief
+*The walkthrough below was published in July 2026 and uses product surfaces that have since been retired (org chart, `@alook.ai` email inboxes, calendar scheduling). The operating pattern—scoped roles, structured handoffs, and human approval boundaries—still applies. For current setup, see the end of this article.*
+
The structure above becomes clearer with a concrete team. On July 3, 2026, [Akshay Pachaar published a public walkthrough](https://x.com/akshay_pachaar/status/2073050056299835736) that sets up a four-agent org chart for one competitive-intelligence job: track a pricing page, schedule the check, and notify a person when something changes.
The roles in that walkthrough:
@@ -285,15 +275,13 @@ That list is incomplete on purpose.
**When should you use multiple AI agents instead of one?** Use multiple agents when stages need different instructions, tools, permissions, context, or review. Keep one agent when the task is short and self-contained, especially when a handoff would only add delay.
-**What is agent email?** It is a durable inbox for an AI agent, separate from a chat session. People and other agents can send instructions, handoffs, and replies that stay attached to the work after a session closes.
-
-**Why do AI agents need their own email address?** A dedicated address makes the agent addressable and keeps decisions in a thread instead of a disappearing chat. Without it, the founder becomes the copy-paste layer between sessions.
+**Why do AI agents need a persistent inbox?** A persistent inbox makes the agent addressable after a session closes. People and other agents can send instructions, handoffs, and replies that stay attached to the work. Without it, the founder becomes the copy-paste layer between sessions.
**Are AI agent departments the same as AI agent roles?** Not exactly. Departments are grouping labels such as research, engineering, or ops. Roles are the actual jobs. Start with roles and handoffs, then add department labels only when several agents share a reporting line.
**How many agents should an AI team have?** Start with the fewest roles needed for one reliable workflow, then add an agent only when a real handoff requires it.
-**Which AI agents does Alook support?** Claude Code, Codex, and OpenCode are available today. Cursor, Hermes, and OpenClaw are listed as coming soon.
+**Which AI agents does Alook support?** Claude Code, Codex, Cursor, OpenCode, and Pi.
**Does an AI agent team still need human oversight?** Yes. People should approve customer commitments, financial actions, legal decisions, pricing changes, and high-risk production work. Design those gates before the agents start acting.
@@ -303,7 +291,7 @@ Name the artifact first.
Choose a workflow you already understand. Define two stages, write down what moves between them, and decide where a person must approve the result. If you cannot name that artifact yet, stay on a single agent.
-To set up Alook for your local coding agents, run `npx @alook/app onboard`. You can also review the project on [GitHub](https://github.com/alookai/alook) or browse the current [Alook templates](https://alook.ai/templates).
+To set up Alook for your local coding agents, register at [alook.ai](https://alook.ai) and pair your machine, or self-host from [GitHub](https://github.com/alookai/alook) (requires email/password login; OAuth and email sending are unavailable in self-host mode).
## Related
diff --git a/src/web/src/content/ai-team-vs-ai-tools.mdx b/src/web/src/content/ai-team-vs-ai-tools.mdx
index 69cded25a..9729ab2e5 100644
--- a/src/web/src/content/ai-team-vs-ai-tools.mdx
+++ b/src/web/src/content/ai-team-vs-ai-tools.mdx
@@ -2,7 +2,7 @@ export const metadata = {
slug: 'ai-team-vs-ai-tools',
title: 'AI Team vs AI Tools: Stop Being the Human Copy-Paste Between Your Coding Agents',
date: '2026-06-15',
- author: 'Donia',
+ author: 'Alook Team',
excerpt: 'AI team vs AI tools comes down to coordination. Isolated coding assistants lose context; a coordinated team shares decisions, handoffs, and workflow state.',
readingTime: '8 min read'
};
diff --git a/src/web/src/content/claude-code-and-codex-same-team.mdx b/src/web/src/content/claude-code-and-codex-same-team.mdx
index 5d8e9f4f1..c779dab24 100644
--- a/src/web/src/content/claude-code-and-codex-same-team.mdx
+++ b/src/web/src/content/claude-code-and-codex-same-team.mdx
@@ -22,7 +22,7 @@ export const jsonLd = [
name: "How do you use Claude and Codex together?",
acceptedAnswer: {
"@type": "Answer",
- text: "Run both against the same repo, assign stable roles, move code through Git, and pass handoffs the next runtime can act on. When sessions close, add identities, threads, or task records so review findings and implementation updates do not depend on you pasting between terminals.",
+ text: "Run both against the same repo, assign stable roles, move code through Git, and pass handoffs the next runtime can act on. When sessions close, add identities, threads, or marks so review findings and implementation updates do not depend on you pasting between terminals.",
},
},
{
@@ -95,7 +95,7 @@ This section describes public product models, not a ranking of which tool is "be
Inside a single Claude Code session, you can delegate to [specialized subagents](https://docs.anthropic.com/en/docs/claude-code/sub-agents). Subagents run in separate context windows, work on scoped tasks, and return results to the main session. That is orchestration within one runtime. For how that nested model differs from independent agents, see [Claude Code subagents vs independent agents](/blog/claude-code-subagents-vs-independent-agents).
-Claude Code can also run [dynamic workflows](https://docs.anthropic.com/en/docs/claude-code/workflows) for large parallel jobs inside the same ecosystem. We covered how that differs from persistent cross-session coordination in our guide to [Claude Code dynamic workflows and email-based agent coordination](/blog/claude-code-dynamic-workflow-alternative). This article focuses on a different problem: coordinating Claude Code with an independent Codex runtime.
+Claude Code can also run [dynamic workflows](https://docs.anthropic.com/en/docs/claude-code/workflows) for large parallel jobs inside the same ecosystem. We covered how that differs from persistent cross-session coordination in our guide to [Claude Code dynamic workflows vs async coordination](/blog/claude-code-dynamic-workflow-alternative). This article focuses on a different problem: coordinating Claude Code with an independent Codex runtime.
### Codex
@@ -204,15 +204,11 @@ It is a poor fit for a single quick question inside one runtime, or for work tha
### Publicly documented setup
-From the project onboarding flow:
+Two paths:
-1. Install and run onboarding:
+1. **Hosted:** Register at [alook.ai](https://alook.ai), pair your machine with the generated daemon command, and connect the local environments where Claude Code and Codex run.
-```bash
-npx @alook/app onboard
-```
-
-2. Or register at [alook.ai](https://alook.ai), pair your machine, and connect the local environments where Claude Code and Codex run. Self-hosting from GitHub is the other path when you want the control plane on your own infra.
+2. **Self-hosted:** Run `npx @alook/app onboard` to start four Wrangler services plus the local daemon. Note: self-host disables OAuth login (email/password required) and email sending/receiving is unavailable.
3. Create agents with distinct roles so each runtime has a clear owner for implementation, review, or research.
@@ -230,7 +226,7 @@ A minimal cross-runtime team **could** be configured like this:
Work flows: you assign a scoped task to Builder → Builder commits and sends a handoff with branch, files, and open questions → Reviewer receives the task → Reviewer returns findings → Builder addresses them → you merge when satisfied.
-That pattern mirrors the example workflow earlier. Alook supplies the shared room, identities, and task visibility; each runtime still executes commands and edits files locally.
+That pattern mirrors the example workflow earlier. Alook supplies the shared room, identities, and message history; each runtime still executes commands and edits files locally.
![Org chart with a human owner, a Builder agent on Claude Code, and a Reviewer agent on Codex connected by handoff arrows](/blog/claude-code-and-codex-same-team/team-setup.webp)
@@ -239,7 +235,7 @@ That pattern mirrors the example workflow earlier. Alook supplies the shared roo
- Agent identity across rooms
- Role ownership across runtimes
- Durable threads that outlive a single CLI session
-- Task visibility and progress tracking
+- Ownership and status visible in messages and marks
- Cross-runtime handoff routing
### What Claude Code and Codex still control
@@ -261,7 +257,7 @@ For broader team design, see [AI agent orchestration](/blog/ai-agent-orchestrati
## Claude Code and Codex FAQ
-**How do you use Claude and Codex together?** Run both against the same repo, assign stable roles, move code through Git, and pass handoffs the next runtime can act on. When sessions close, add identities, threads, or task records so review findings and implementation updates do not depend on you pasting between terminals.
+**How do you use Claude and Codex together?** Run both against the same repo, assign stable roles, move code through Git, and pass handoffs the next runtime can act on. When sessions close, add identities, threads, or marks so review findings and implementation updates do not depend on you pasting between terminals.
**Codex vs Claude Code: which should you use?** Neither wins every job. Pick by task, subscription, and habit. Many teams keep both and split implementation from review instead of forcing every slice into one runtime.
diff --git a/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx b/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx
index 9b551362c..b8de53ea5 100644
--- a/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx
+++ b/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx
@@ -1,20 +1,19 @@
export const metadata = {
slug: "claude-code-dynamic-workflow-alternative",
- title: "OpenCode Dynamic Workflow: Claude Code vs Email Coordination",
+ title: "OpenCode Dynamic Workflow: Claude Code vs Async Coordination",
date: "2026-06-01",
dateModified: "2026-08-10",
author: "Alook Team",
excerpt:
- "OpenCode dynamic workflow needs often mean durable coordination. Claude Code stays in-session; email coordination spans OpenCode, Codex, and Claude Code.",
+ "OpenCode dynamic workflow needs often mean durable coordination. Claude Code stays in-session; async room-based coordination spans Claude Code, Codex, Cursor, OpenCode, and Pi.",
readingTime: "4 min read",
- image: "/blog/claude-code-dynamic-workflow-alternative/seo-team.png",
};
If you searched for an **OpenCode dynamic workflow**, start here: Claude Code’s dynamic workflows run inside Claude Code. They are strong for huge parallel jobs in one session. OpenCode does not inherit that same in-session workflow engine. Teams that run OpenCode (or mix OpenCode with Codex and Claude Code) usually need a separate coordination path when work must last more than one sitting.
Claude Code dynamic workflows: write JavaScript, run many agents, keep working in that session. Great if you stay in one Claude Code session and work alone.
-Alook took a different path because agent work often needs to survive overnight and move between people. Dynamic workflows and email-style coordination solve different jobs.
+Alook took a different path because agent work often needs to survive overnight and move between people. Dynamic workflows and async room-based coordination solve different jobs.
## Dynamic Workflows Do One Thing Really Well
@@ -43,54 +42,42 @@ Dynamic workflows run through Claude Code on Anthropic's infrastructure (or your
**Claude Code dynamic workflows** orchestrate many agents inside one Claude Code session with JavaScript. They shine when the whole job finishes before you close that session.
-**OpenCode** is a supported local runtime in Alook’s coordination layer today, alongside Codex and Claude Code. If your question is how to get multi-step agent work with OpenCode that lasts across days, you usually need email-style or room-style coordination rather than Claude Code’s session-bound workflow runner.
+**OpenCode** is a supported local runtime in Alook today, alongside Claude Code, Codex, Cursor, and Pi. If your question is how to get multi-step agent work with OpenCode that lasts across days, you usually need async room-based coordination rather than Claude Code’s session-bound workflow runner.
-## We went with email instead
+## We went with async messaging instead
-Sounds primitive. Agents literally email each other. That is also why it works across sessions, across weeks, and across teammates.
+Agents message each other through persistent channels and DMs. That is also why it works across sessions, across weeks, and across teammates.
-Alook does this. While dynamic workflows only work in Claude Code, Alook connects to Codex, OpenCode, and Claude Code today. Cursor, Hermes, and OpenClaw are listed as coming soon.
+Alook does this. While dynamic workflows only work in Claude Code, Alook connects to Claude Code, Codex, Cursor, OpenCode, and Pi today.
### Agents Get Their Own Space
-```
-Donia (Lead) routes work
- ├─ Oralla codes
- ├─ Rosanna researches
- ├─ Vera writes
- └─ Kai tracks metrics
-```
-
-![Agent organization structure](/blog/claude-code-dynamic-workflow-alternative/seo-team.png)
-
-Each agent has a separate workspace. No shared state bugs. Everything logs to `.context_timeline/*.jsonl` files you can grep later. Email threads become documentation. Schedule recurring tasks like meetings.
+Each agent has a separate workspace with its own handle and memberships. Message threads become documentation.
### Watching It Work Over Weeks
-Our SEO program works like this. Monday: Rosanna finds keywords. Wednesday: Vera writes posts. Friday: Oralla ships them. Following week: Kai reports numbers. Adjust based on data. Repeat.
-
-The agents keep durable references. Vera can cite keyword research from earlier weeks. Oralla can reuse deployment patterns that already worked. Kai can track trends across months. That kind of continuity is hard to keep in one browser tab.
+A content program works like this: one agent finds keywords on Monday. Another writes posts midweek. A third ships them on Friday. A fourth reports numbers the following week. Adjust based on data. Repeat.
-In May 2026, our SEO program logged 3 published articles, 173 impressions, 41 clicks, and a 23.70% CTR in Search Console, with 87 tasks recorded over 18 days. Small numbers, but each task stayed searchable in the timeline.
+The agents keep durable references. A writer can cite keyword research from earlier weeks. A deployer can reuse patterns that already worked. An analyst can track trends across months. That kind of continuity is hard to keep in one browser tab.
## When Each One Wins
-| Feature | Claude Code Dynamic Workflow | Email Coordination (Alook) |
+| Feature | Claude Code Dynamic Workflow | Async Coordination (Alook) |
|---------|------------------------------|----------------------------|
| **Sweet spot** | 500 files, right now | 3-month project |
| **How long** | Hours in one session | Weeks to months |
| **Who uses it** | You, alone | Team with handoffs |
-| **Memory** | Cached within a session; fresh on new session | Permanent timeline |
-| **Agent communication** | JavaScript | Email |
-| **Can pause?** | Yes, within the same session (`/workflows`) | Yes, async everything |
-| **Where it runs** | Claude Code on paid plans, API, Bedrock, Agent Platform, Foundry | Your servers |
-| **Frameworks** | Claude Code | Codex, OpenCode, Claude Code; Cursor, Hermes, OpenClaw coming soon |
+| **Memory** | Cached within a session; fresh on new session | Persistent message history |
+| **Agent communication** | JavaScript | Channels and DMs |
+| **Can pause?** | Yes, within the same session (`/workflows`) | Yes, messages wait for reconnect |
+| **Where it runs** | Claude Code on paid plans, API, Bedrock, Agent Platform, Foundry | Hosted rooms + local runtimes (or self-hosted) |
+| **Frameworks** | Claude Code | Claude Code, Codex, Cursor, OpenCode, Pi |
## Audit 500 Files or Run a Program?
Need to check hundreds of API endpoints for auth bugs right now? Dynamic workflow. Script the fan-out, let many agents each take a slice, get a merged report in one session.
-Building a content program? Email coordination. Research accumulates. Writing improves based on what worked. Deployment follows a checklist that evolves. Analytics inform next week's topics. You can't script that ahead of time because you don't know what you'll learn.
+Building a content program? Async coordination. Research accumulates. Writing improves based on what worked. Deployment follows a checklist that evolves. Analytics inform next week's topics. You can't script that ahead of time because you don't know what you'll learn.
## Using Dynamic Workflows
@@ -101,32 +88,20 @@ Enable in settings, then:
Watch the progress bar. See agent count, token spend, partial results.
-## Using Email Coordination
-
-Hit alook.ai, make an account. You get Donia immediately.
-
-![Chat interface showing task input](/blog/claude-code-dynamic-workflow-alternative/chat-interface.jpg)
-
-Type what you need:
-```
-Research our top 5 competitors and explain
-what makes us different
-```
-
-Donia emails the right agent. You see it happen in the activity feed.
+## Using Async Coordination
-![Email activity feed](/blog/claude-code-dynamic-workflow-alternative/email-inbox.png)
+Register at alook.ai or self-host. Connect a local runtime.
Illustrative handoff shape:
-- You: "Write API rate limiting best practices post"
-- Donia → Rosanna: "Research rate limiting approaches"
-- Rosanna → Donia: "Found patterns with tradeoffs" (hours later)
-- Donia → Vera: "Write post from attached research"
-- Vera → Donia: "Draft attached" (next morning)
-- Donia → you: "Post ready for review"
+- You: "Write API rate limiting best practices post" (channel message)
+- Lead agent → Research agent: "Research rate limiting approaches" (DM)
+- Research agent → Lead: "Found patterns with tradeoffs" (hours later)
+- Lead → Writer agent: "Write post from attached research"
+- Writer → Lead: "Draft attached" (next morning)
+- Lead → you: "Post ready for review"
-Everything saved. Search it later. Agents can reference it next time.
+Messages persist in channels and DMs. Agents can reference prior handoffs in later sessions.
## Same job, two coordination styles
@@ -134,7 +109,7 @@ Suppose you need a security pass over an auth surface.
**Dynamic workflow:** write the orchestration script, fan out many agents in one session, get a broad coverage report before you close the window. Strong when breadth matters more than multi-day continuity.
-**Email coordination:** brief one agent, let it work asynchronously, review findings when ready. A later pass can reuse prior notes and check for regressions because the thread and timeline persist. Strong when explanation and follow-up matter more than raw fan-out speed.
+**Async coordination:** brief one agent, let it work asynchronously, review findings when ready. A later pass can reuse prior notes and check for regressions because the thread and timeline persist. Strong when explanation and follow-up matter more than raw fan-out speed.
Speed is not the only difference. Coverage versus durable understanding is.
@@ -142,8 +117,8 @@ Speed is not the only difference. Coverage versus durable understanding is.
Claude Code dynamic workflows demolish single-session parallel work. Migrations, comprehensive audits, "check everything right now" tasks.
-Email coordination handles everything that unfolds over time. Programs that run for months. Work that moves between people. Context that matters next week.
+Async coordination handles everything that unfolds over time. Programs that run for months. Work that moves between people. Context that matters next week.
-They solve different problems. We use email-style coordination to run our product team. When someone needs a large one-shot audit, they can still trigger a dynamic workflow, then bring results back into the durable thread for the next person.
+They solve different problems. We use room-based coordination to run our product team. When someone needs a large one-shot audit, they can still trigger a dynamic workflow, then bring results back into the durable thread for the next person.
-**About Alook:** Open-source agent coordination platform. Self-hosted option. Works with Codex/OpenCode/Claude Code. [GitHub](https://github.com/alookai/alook) | [Docs](https://github.com/alookai/alook/blob/main/AGENTS.md)
+**About Alook:** Open-source communication platform for local coding agents. Hosted or self-hosted. Works with Claude Code, Codex, Cursor, OpenCode, and Pi. [GitHub](https://github.com/alookai/alook) | [alook.ai](https://alook.ai)
diff --git a/src/web/src/content/claude-code-subagents-vs-independent-agents.mdx b/src/web/src/content/claude-code-subagents-vs-independent-agents.mdx
index 3a7790ace..b2334ce5e 100644
--- a/src/web/src/content/claude-code-subagents-vs-independent-agents.mdx
+++ b/src/web/src/content/claude-code-subagents-vs-independent-agents.mdx
@@ -171,7 +171,7 @@ If not, stay nested. If yes, pick the middle or right-hand model on purpose inst
## Where a coordination layer fits
-A coordination layer does not replace Claude Code subagents. The two solve different problems: subagents help a Claude Code session delegate focused work while protecting its context, while a coordination layer helps separate agents recover decisions, identify ownership, and pass work across session or runtime boundaries. We built [Alook](https://alook.ai) for the second case. Local coding agents retain their underlying runtimes, while roles, email threads, task status, and recorded history provide continuity outside any single conversation. That arrangement can still include subagents, so a Claude Code agent may use nested helpers to explore a repository and then hand the resulting implementation to an independent Codex reviewer.
+A coordination layer does not replace Claude Code subagents. The two solve different problems: subagents help a Claude Code session delegate focused work while protecting its context, while a coordination layer helps separate agents recover decisions, identify ownership, and pass work across session or runtime boundaries. We built [Alook](https://alook.ai) for the second case. Local coding agents retain their underlying runtimes, while roles, message threads, and recorded history provide continuity outside any single conversation. That arrangement can still include subagents, so a Claude Code agent may use nested helpers to explore a repository and then hand the resulting implementation to an independent Codex reviewer.
The nested work stays inside Claude Code.
diff --git a/src/web/src/content/how-to-delegate-tasks-to-ai-agents.mdx b/src/web/src/content/how-to-delegate-tasks-to-ai-agents.mdx
index a964ad1b0..b4f6338df 100644
--- a/src/web/src/content/how-to-delegate-tasks-to-ai-agents.mdx
+++ b/src/web/src/content/how-to-delegate-tasks-to-ai-agents.mdx
@@ -300,7 +300,7 @@ If any answer is fuzzy, keep the task with a human for one more cycle.
## Where Alook fits
-[Alook](https://alook.ai) is one way to keep delegated coding-agent work organized once the method is clear: roles, email-native handoffs, boards, calendars, and recorded context. The method still comes first. Without a delegable task definition, any platform just automates confusion faster.
+[Alook](https://alook.ai) is one way to keep delegated coding-agent work organized once the method is clear: roles, persistent message threads, and recorded context. The method still comes first. Without a delegable task definition, any platform just automates confusion faster.
## How to delegate tasks to AI agents FAQ
diff --git a/src/web/src/content/human-ai-collaboration-small-teams.mdx b/src/web/src/content/human-ai-collaboration-small-teams.mdx
index 07d2cbe91..540bf389b 100644
--- a/src/web/src/content/human-ai-collaboration-small-teams.mdx
+++ b/src/web/src/content/human-ai-collaboration-small-teams.mdx
@@ -3,7 +3,7 @@ export const metadata = {
title: "Human-AI Collaboration for Small Teams",
date: "2026-06-30",
dateModified: "2026-08-11",
- author: "Donia",
+ author: "Alook Team",
excerpt:
"Human-AI collaboration for small teams means humans and AI working together across roles, shared channels, and approval nodes, not one chat at a time.",
readingTime: "8 min read",
@@ -158,7 +158,7 @@ If you're a solo founder or small team still working with one AI at a time, here
The industry shape for mixed human-agent work is getting familiar. Products such as [Buzz](https://buzz.xyz) put humans and agents in Discord-like servers and channels: one place to talk, assign work, and see who (or which agent) replied.
-[Alook](https://alook.ai) is deploying that same kind of collaboration surface. Your team opens a shared room. People and local coding agents show up as participants. Mentions, threads, and channel history replace the tab-hopping between private chats. Roles, email inboxes, boards, and calendars still sit underneath so work does not evaporate when a thread moves on.
+[Alook](https://alook.ai) is deploying that same kind of collaboration surface. Your team opens a shared room. People and local coding agents show up as participants. Mentions, threads, and channel history replace the tab-hopping between private chats. Roles, a persistent inbox, and message history still sit underneath so work does not evaporate when a thread moves on.
That mix is what small teams need for human and AI working together without giving up local runtimes. You can self-host from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect the agents on your machine.
diff --git a/src/web/src/content/keep-context-across-coding-agent-sessions.mdx b/src/web/src/content/keep-context-across-coding-agent-sessions.mdx
index a4585ee78..57766401f 100644
--- a/src/web/src/content/keep-context-across-coding-agent-sessions.mdx
+++ b/src/web/src/content/keep-context-across-coding-agent-sessions.mdx
@@ -145,7 +145,7 @@ The layers above still leave you as the sync point: read one session's output, p
When that bridging is daily, the missing piece is not "more memory files." It is a channel between sessions: persistent identity so work can address a specific agent, explicit task ownership, and threads that survive restarts on both sides.
-We built [Alook](https://alook.ai) as that coordination layer for local coding agents. Agents keep their own runtimes and in-tool memory. Alook adds roles, email-native threads, and task handoffs that outlast a single chat window. See [supported agents](/blog/ai-agent-team#supported-agents) for the current runtime list, and [how to build an AI agent team](/blog/ai-agent-team) for roles and handoffs.
+We built [Alook](https://alook.ai) as that coordination layer for local coding agents. Agents keep their own runtimes and in-tool memory. Alook adds roles, persistent message threads, and handoffs that outlast a single chat window. See [supported agents](/blog/ai-agent-team#supported-agents) for the current runtime list, and [how to build an AI agent team](/blog/ai-agent-team) for roles and handoffs.
Context can persist in files, in Git, in runtime memory, in handoff notes. Each carries something. None carries everything. The more agents and sessions you run, the more useful it becomes to connect them rather than reconciling them yourself.
diff --git a/src/web/src/content/multi-agent-collaboration-without-code.mdx b/src/web/src/content/multi-agent-collaboration-without-code.mdx
index eda09ca2d..a67f85427 100644
--- a/src/web/src/content/multi-agent-collaboration-without-code.mdx
+++ b/src/web/src/content/multi-agent-collaboration-without-code.mdx
@@ -4,13 +4,13 @@ export const metadata = {
date: "2026-07-07",
author: "Alook Team",
excerpt:
- "Multi-agent collaboration needs more than parallel runs. Shared context, specialized roles, autonomous handoffs, and communication make it work without code.",
+ "Multi-agent collaboration needs more than parallel runs. Shared rooms, specialized roles, structured handoffs, and persistent communication make it work without writing orchestration code.",
readingTime: "4 min read",
};
AI agents keep getting more capable. Better reasoning, longer context, more tools. But most people still use them one at a time: ask a question, get an answer, ask the next question. And when that bottleneck becomes obvious, the instinct is to just run more agents in parallel. That doesn't work either.
-Multi-agent collaboration means agents that coordinate with each other autonomously. No scripting, no workflow builders, no code. You define roles and relationships. The agents handle the rest.
+Multi-agent collaboration means agents that coordinate through shared rooms and explicit operating rules. You define roles, relationships, and handoff expectations. The agents communicate through persistent channels and DMs without you writing orchestration code or wiring workflow builders.
![Illustration of multi-agent collaboration without code for business workflows](/blog/multi-agent-collaboration-without-code/hero.png)
@@ -32,17 +32,17 @@ More agents without coordination doesn't scale. It multiplies contradictions.
## How multi-agent collaboration works without code
-You don't need to write scripts or build workflow diagrams to get agents working together. The no-code approach to multi-agent collaboration works through four mechanisms:
+You don't need to write orchestration scripts or build workflow diagrams to get agents working together. The no-code approach works through four mechanisms:
-**Shared context.** Agents access the same information layer. When your dev agent ships a fix, your support agent knows immediately. No manual syncing, no stale information, no contradictions between what different agents tell your customers.
+**Shared rooms.** Agents participate in the same channels and threads. When your dev agent posts an update, your support agent can read it in the same room. No manual syncing between separate chat windows.
-**Role specialization.** Each agent owns a domain: content, support, research, operations. You describe the role in plain language. The agent builds expertise within that function rather than being a generalist spread thin across everything.
+**Role specialization.** Each agent owns a domain: content, support, research, operations. You describe the role in plain language and give it operating rules. The agent builds expertise within that function rather than being a generalist spread thin across everything.
-**Autonomous handoffs.** When content finishes a draft that needs SEO review, it passes directly to the SEO agent. Work flows agent-to-agent without you sitting in the middle forwarding messages between sessions.
+**Structured handoffs through messages.** When content finishes a draft that needs SEO review, it sends the handoff in a message or thread. The SEO agent picks it up from its inbox. Work moves agent-to-agent through persistent communication rather than you copying between terminals.
-**Communication channels.** Agents message each other. Your SEO agent finds a better keyword angle and notifies content to adjust. Your operations agent flags a scheduling conflict and alerts the team. Coordination happens without you routing every update.
+**Persistent communication.** Agents message each other through channels and DMs. Your SEO agent finds a better keyword angle and notifies content to adjust. Your operations agent flags a scheduling conflict in the shared room. Coordination happens through the same messaging surface people use.
-No workflow builders. No if-then logic. No API connections to maintain. You set up the team structure, and the collaboration emerges from the roles and relationships you defined.
+No workflow builders. No if-then logic. No API connections to maintain. You set up roles, write operating rules, and the agents communicate through persistent rooms.
![Diagram showing how shared context, role specialization, handoffs, and communication power multi-agent collaboration](/blog/multi-agent-collaboration-without-code/collaboration-mechanisms.png)
@@ -53,9 +53,9 @@ For a deeper look at coordination patterns, see our guide on [AI agent orchestra
| Dimension | Single agent | Multi-agent collaboration |
|-----------|-------------|--------------------------|
| Execution | Sequential: one task at a time | Parallel: multiple tasks simultaneously |
-| Context | Isolated per session | Shared across all agents |
-| Coordination | You are the router | Agents coordinate autonomously |
-| Scaling | More tasks = more of your time | More agents, same amount of your time |
+| Context | Isolated per session | Shared room/message history; private runtime context stays separate |
+| Coordination | You are the router | Agents communicate through shared rooms |
+| Scaling | More tasks = more of your time | More agents can run in parallel |
| Setup | Prompt engineering | Describe roles in plain language |
| Your role | Operator | Director |
@@ -72,4 +72,4 @@ For isolated, single-domain tasks where one agent handles everything independent
---
-_Alook gives your AI agents shared context, communication channels, and autonomous handoffs: no code required. Build a team that coordinates itself. [Start free](https://alook.ai)._
+_Alook gives your AI agents shared rooms, persistent communication, and structured handoffs without writing orchestration code. [Start free](https://alook.ai)._
diff --git a/src/web/src/content/multi-agent-workflow-patterns.mdx b/src/web/src/content/multi-agent-workflow-patterns.mdx
index 58e9c5155..21ffc55b3 100644
--- a/src/web/src/content/multi-agent-workflow-patterns.mdx
+++ b/src/web/src/content/multi-agent-workflow-patterns.mdx
@@ -43,7 +43,7 @@ export const jsonLd = [
name: "Which agents does Alook support?",
acceptedAnswer: {
"@type": "Answer",
- text: "Alook currently supports Claude Code, Codex, and OpenCode. Cursor, Hermes, and OpenClaw are listed as coming soon.",
+ text: "Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi.",
},
},
],
@@ -138,7 +138,7 @@ The output should answer a few plain questions:
Do not give agents unrestricted production access because a workflow looks routine. Restarting a service, rolling back a deploy, or changing infrastructure can be safe in one system and risky in another. The workflow should encode those boundaries.
-Alook's email-native model fits this kind of loop because every agent can have its own address and the handoff can happen through recorded messages. The point is not chatty agents. It is a traceable trail of what each role saw and decided.
+Alook's message-based model fits this kind of loop because every agent has its own inbox and handoffs happen through recorded messages in channels and DMs. The point is not chatty agents. It is a traceable trail of what each role saw and decided.
## Pattern 5: Daily research brief
@@ -202,11 +202,11 @@ Avoid starting with strategy, taste, negotiation, or live production decisions.
## How Alook fits
-[Alook](https://alook.ai) is an open-source, self-hostable orchestration layer for local AI coding agents. It gives agents roles, email addresses, task boards, calendars, persistent context, and recorded communication so they can work more like a coordinated team.
+[Alook](https://alook.ai) is an open-source communication platform for local AI coding agents, available hosted or self-hosted. It gives agents roles, a persistent inbox, channels and DMs, and recorded communication so they can work more like a coordinated team.
The important part is state. A workflow is hard to trust when every agent starts from a blank chat. Alook is designed around persistent context and traceability, so the investigator's findings, the developer's patch, the reviewer report, and the human decision can stay connected.
-Alook currently supports Claude Code, Codex, and OpenCode. It is built for indie developers, solopreneurs, one-person companies, open-source maintainers, and indie hackers who want their local agents to keep working without turning every handoff into manual copy-paste.
+Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi. It is built for indie developers, solopreneurs, one-person companies, open-source maintainers, and indie hackers who want their local agents to keep working without turning every handoff into manual copy-paste.
## Multi-agent workflow FAQ
@@ -224,6 +224,6 @@ Start with the smallest workflow that has a real handoff. Many teams begin with
**Which agents does Alook support?**
-Alook currently supports Claude Code, Codex, and OpenCode. Cursor, Hermes, and OpenClaw are listed as coming soon.
+Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi.
Want to apply these patterns to a larger operating model? Read how a [personal AI company](/blog/personal-ai-company) can be structured around coordinated agents.
diff --git a/src/web/src/content/multiple-ai-agents-edit-same-repository.mdx b/src/web/src/content/multiple-ai-agents-edit-same-repository.mdx
index 98b16cd5b..552921f64 100644
--- a/src/web/src/content/multiple-ai-agents-edit-same-repository.mdx
+++ b/src/web/src/content/multiple-ai-agents-edit-same-repository.mdx
@@ -126,9 +126,9 @@ Day-to-day operating rules for briefs and approval gates live in [How to Run an
These rules do not require Alook. They get easier to follow when each assignment, path scope, and next step stays visible outside the prompt that started the task.
-**Alook keeps agent roles, threads, and task assignments visible while the agents continue to run on your machine.** A path scope such as `src/auth/` can stay in the task record instead of living only in a temporary prompt. Review can move to another agent, while merge approval stays with you.
+**Alook keeps agent roles and threads visible in persistent rooms while the agents continue to run on your machine.** A path scope such as `src/auth/` can be recorded in a message or mark instead of living only in a temporary prompt. Review can move to another agent, while merge approval stays with you.
-You can self-host Alook from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect your local runtime. **Alook helps show who is assigned to the work. Git still records and merges the code.** It does not resolve merge conflicts or replace your editor.
+You can self-host Alook from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect your local runtime. **Alook helps show who owns the work through rooms and messages. Git still records and merges the code.** It does not resolve merge conflicts or replace your editor.
## Keep the repo readable
diff --git a/src/web/src/content/no-code-automation-ai-agents.mdx b/src/web/src/content/no-code-automation-ai-agents.mdx
index 9c698465f..50ed3c4b6 100644
--- a/src/web/src/content/no-code-automation-ai-agents.mdx
+++ b/src/web/src/content/no-code-automation-ai-agents.mdx
@@ -35,7 +35,7 @@ export const jsonLd = [
name: "Can you automate repetitive tasks without coding and still use multiple AI agents?",
acceptedAnswer: {
"@type": "Answer",
- text: "Yes. You describe each agent's role and the handoffs in plain language instead of building workflow graphs or writing scripts. The coordination happens through shared context and defined roles, not custom orchestration code.",
+ text: "Yes. You describe each agent's role and the handoffs in plain language instead of building workflow graphs or writing scripts. Agents communicate through persistent rooms and operating rules you define, not custom orchestration code.",
},
},
{
@@ -120,22 +120,16 @@ Most solo founders and small teams end up running both. A few trigger-and-action
## Where Alook fits
-[Alook](https://alook.ai) is an open-source, self-hosted platform that turns local AI coding agents into a coordinated team. You describe roles and relationships; the agents collaborate without you writing orchestration code. It currently supports Claude Code, Codex, and OpenCode. The project lives on [GitHub](https://github.com/alookai/alook).
+[Alook](https://alook.ai) is an open-source communication platform that gives local AI coding agents a shared coordination surface. You describe roles and relationships; agents communicate through persistent rooms and DMs rather than requiring you to write orchestration code. It currently supports Claude Code, Codex, Cursor, OpenCode, and Pi. The project lives on [GitHub](https://github.com/alookai/alook).
Alook gives those agents an operating structure:
-- Roles and an org chart that define who owns each kind of work
-- An `@alook.ai` email address so people and agents exchange instructions and replies
-- Kanban task tracking for assignments and progress
-- Calendar scheduling for reminders, recurring tasks, and routines
+- Roles and memberships that define who owns each kind of work
+- A persistent inbox so people and agents exchange instructions and replies
- Persistent context and a trace of instructions, decisions, and responses
- Local execution, so agents and their tool access stay on your machine while you reach them from anywhere
-You can start for free: register at [alook.ai](https://alook.ai), then connect your local runtime. The project is Apache 2.0 licensed and can be self-hosted. To set it up from your terminal:
-
-```bash
-npx @alook/app onboard
-```
+You can start for free: register at [alook.ai](https://alook.ai), then connect your local runtime. The project is Apache 2.0 licensed and can be self-hosted.
## No-code automation FAQ
@@ -149,7 +143,7 @@ No. Trigger-and-action automation moves data on fixed rules. AI agent automation
**Can you automate repetitive tasks without coding and still use multiple AI agents?**
-Yes. You describe each agent's role and the handoffs in plain language instead of building workflow graphs. The coordination runs on shared context and defined roles.
+Yes. You describe each agent's role and the handoffs in plain language instead of building workflow graphs. Coordination happens through persistent rooms and operating rules you define for each agent.
**When should you use trigger-and-action tools vs an AI agent team?**
@@ -157,4 +151,4 @@ Use trigger-and-action tools for clear, rule-based steps between apps. Use an AI
## Start with one workflow
-Pick the process that eats the most of your attention right now. If it is a straight "when X, do Y," a trigger-and-action tool solves it today. If it needs judgment across a few roles, that is where agents with shared context earn their place. Try Alook by running `npx @alook/app onboard`, or read more at [alook.ai](https://alook.ai).
+Pick the process that eats the most of your attention right now. If it is a straight "when X, do Y," a trigger-and-action tool solves it today. If it needs judgment across a few roles, that is where agents with shared context earn their place. Try Alook at [alook.ai](https://alook.ai), or self-host from [GitHub](https://github.com/alookai/alook).
diff --git a/src/web/src/content/personal-ai-company.mdx b/src/web/src/content/personal-ai-company.mdx
index a8cbe98c4..566fc5b8b 100644
--- a/src/web/src/content/personal-ai-company.mdx
+++ b/src/web/src/content/personal-ai-company.mdx
@@ -52,7 +52,7 @@ export const jsonLd = [
name: "Which AI agents does Alook support?",
acceptedAnswer: {
"@type": "Answer",
- text: "See the current supported agents list on the AI agent team guide. Alook gives local coding agents roles, email inboxes, task tracking, schedules, and a shared workspace for collaboration.",
+ text: "Alook currently supports Claude Code, Codex, Cursor, OpenCode, and Pi. It gives local coding agents roles, a persistent inbox, and a shared workspace for collaboration.",
},
},
{
@@ -168,11 +168,11 @@ Vendor tooling inside one product can help peers coordinate. Anthropic’s [Clau
A **one-person company** is the shape of the business: one founder stays accountable. An **AI agent team** is how that company runs day to day: scoped roles, handoff artifacts, and approval gates so work moves without you re-explaining context between every step. You do not need a large headcount of agents to have a team; two roles with a clear contract already count.
-For the roles, agent email, and failure modes in detail, read **[How to Build an AI Agent Team](/blog/ai-agent-team)**. Current **[supported agents](/blog/ai-agent-team#supported-agents)** are listed there. For proof of work and always-on operating rules, see [how to run an AI agent team that stays on track](/blog/run-ai-agent-team-that-stays-on-track).
+For roles, persistent communication, and failure modes in detail, read **[How to Build an AI Agent Team](/blog/ai-agent-team)**. Current **[supported agents](/blog/ai-agent-team#supported-agents)** are listed there. For proof of work and always-on operating rules, see [how to run an AI agent team that stays on track](/blog/run-ai-agent-team-that-stays-on-track).
## Building this with Alook
-[Alook](https://alook.ai) is an open-source, self-hosted orchestration platform for local AI coding agents. It gives agents an operating structure: roles and an org chart, individual `@alook.ai` email addresses, Kanban tracking, calendar scheduling, persistent context, traceability, and local execution on your machine. You can currently get started with Alook for free under Apache 2.0, including self-hosting.
+[Alook](https://alook.ai) is an open-source communication platform for local AI coding agents, available hosted or self-hosted. It gives agents an operating structure: roles and memberships, a persistent inbox and DMs, persistent context, traceability, and local execution on your machine. You can currently get started with Alook for free under Apache 2.0, including self-hosting.
That describes Alook’s current availability. It is not a claim about the total cost of running a business or using third-party models and services.
@@ -198,7 +198,7 @@ Pick a recurring job you already do alone: the Friday newsletter, the morning br
Write the artifact you expect, the tools the agent may touch, and the moment you must approve before anything reaches a customer. When that loop is boring in a good way, add the next handoff. Until then, one reliable workflow beats a pretend org chart.
-To connect local coding agents under Alook, run `npx @alook/app onboard`. Templates and product details live at [alook.ai](https://alook.ai).
+To connect local coding agents under Alook, register at [alook.ai](https://alook.ai) and pair your machine. Self-hosting is also available from [GitHub](https://github.com/alookai/alook) (email/password login required; OAuth and email sending unavailable in self-host mode).
## Related
diff --git a/src/web/src/content/prevent-coding-agents-duplicating-work.mdx b/src/web/src/content/prevent-coding-agents-duplicating-work.mdx
index 0c29ec7f1..51194e2d0 100644
--- a/src/web/src/content/prevent-coding-agents-duplicating-work.mdx
+++ b/src/web/src/content/prevent-coding-agents-duplicating-work.mdx
@@ -120,7 +120,7 @@ Before dispatching another agent, ask one plain question: **What will it produce
These rules work in an issue tracker, a task file, or a project board. The tool matters less than the routine: claim first, update status, and leave a link when the work closes. The weak point is usually manual upkeep. Once agents run across sessions or while you are away, stale status makes claimed work look available.
-Alook keeps assignments, task status, threads, and agent activity visible around local coding agents such as Claude Code and Codex. You can self-host it from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect a runtime that stays on your machine. Alook does **not** infer that two differently worded briefs mean the same goal, auto-merge duplicate tasks, or lock files. Your claiming and rejection rules make that decision; Alook gives those decisions a persistent place where you can see them.
+Alook gives local coding agents such as Claude Code and Codex a shared room where ownership and status stay visible in persistent messages, threads, and marks. You can self-host from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect a runtime that stays on your machine. Alook does **not** infer that two differently worded briefs mean the same goal, auto-merge duplicate tasks, or lock files. Your claiming and rejection rules make that decision; Alook gives those decisions a persistent place where you can see them.
Duplicate work often begins before an agent writes code. Make the claim visible, carry decisions forward, and tell the next session exactly what remains. Then parallel agents can work on separate outcomes instead of producing a second version of the first one.
@@ -136,7 +136,7 @@ Usually no. Git detects overlapping file changes, while task duplication can pro
Include the goal, definition of done, current owner and status, links to existing artifacts, rejected approaches with reasons, and the remaining gap. The next agent should be able to identify its new contribution without reconstructing the earlier session.
**Does Alook automatically detect duplicate work?**
-No. Alook makes assignments and task history visible, but it does not decide that two briefs describe the same goal. A person or agent still needs to check, claim the task, and resolve any overlap.
+No. Alook makes ownership and history visible through rooms and messages, but it does not decide that two briefs describe the same goal. A person or agent still needs to check, claim the work, and resolve any overlap.
Related:
diff --git a/src/web/src/content/run-ai-agent-team-that-stays-on-track.mdx b/src/web/src/content/run-ai-agent-team-that-stays-on-track.mdx
index c266d0d4f..699e591d6 100644
--- a/src/web/src/content/run-ai-agent-team-that-stays-on-track.mdx
+++ b/src/web/src/content/run-ai-agent-team-that-stays-on-track.mdx
@@ -44,7 +44,7 @@ export const jsonLd = [
name: "What is an always-on AI agent runtime?",
acceptedAnswer: {
"@type": "Answer",
- text: "An always-on runtime keeps agents available across hours and days so scheduled work, email, and catch-up can continue after a chat session closes. Always-on does not mean unsupervised. High-impact actions still wait for approval.",
+ text: "An always-on runtime keeps agents available across hours and days so scheduled work, unread messages, and catch-up can continue after a chat session closes. Always-on does not mean unsupervised. High-impact actions still wait for approval.",
},
},
{
@@ -164,7 +164,7 @@ Proof can be small. A pull request with checks run. A screenshot. A dated note w
## Always-on runtime is not unsupervised runtime
-An always-on AI agent runtime keeps the team available after a chat window closes. Scheduled checks can fire. Agent email can wait in the inbox. A local daemon can pick work back up when the machine is online.
+An always-on AI agent runtime keeps the team available after a chat window closes. Scheduled checks can fire. Unread messages can wait in the inbox until the agent reconnects and catches up. A local daemon can pick work back up when the machine is online.
That is useful. It is not the same as letting agents spend, publish, or merge without you.
@@ -173,7 +173,7 @@ Keep the distinction explicit:
- **Always-on** means the runtime can continue work across hours and days.
- **Unsupervised** means high-impact actions proceed without a human gate.
-Approval still sits in front of customer commitments, payments, legal language, and production changes. For the email-native handoff pattern behind that runtime, see [how to build an AI agent team](/blog/ai-agent-team).
+Approval still sits in front of customer commitments, payments, legal language, and production changes. For the message-based handoff pattern behind that runtime, see [how to build an AI agent team](/blog/ai-agent-team).
## Give exceptions an owner and a stop path
@@ -200,7 +200,7 @@ Rules become much easier to follow when people and agents know who owns the next
The full walkthrough, including the org chart and screenshots, is in [How to Build an AI Agent Team](/blog/ai-agent-team). The practical lesson here is smaller: a team does not need every agent talking to every other agent. Clear reporting lines reduce the number of places a task can disappear.
-That is the kind of structure Alook is built to hold for agents that run on your own machine: roles, email-native threads, task handoffs, an always-on local runtime, and a history you can inspect later. You can take the open-source, self-hosted route through [GitHub](https://github.com/alookai/alook). Or register at [alook.ai](https://alook.ai), then connect the local agents and runtime you already use. In both paths, the agents continue to run in your environment.
+That is the kind of structure Alook is built to hold for agents that run on your own machine: roles, persistent message threads, task handoffs, an always-on local runtime, and a history you can inspect later. You can take the open-source, self-hosted route through [GitHub](https://github.com/alookai/alook). Or register at [alook.ai](https://alook.ai), then connect the local agents and runtime you already use. In both paths, the agents continue to run in your environment.
## Keep the team usable
@@ -229,7 +229,7 @@ Actions that send, spend, publish, change prices, create legal commitments, or m
A reviewable artifact: a pull request, test output, screenshot, dated note, or deploy link that shows what changed and what remains open. A long chat thread is activity, not proof.
**What is an always-on AI agent runtime?**
-It keeps agents available across hours and days so scheduled work, email, and catch-up can continue after a chat session closes. Always-on does not mean unsupervised. High-impact actions still wait for approval.
+It keeps agents available across hours and days so scheduled work, unread messages, and catch-up can continue after a chat session closes. Always-on does not mean unsupervised. High-impact actions still wait for approval.
**What should an AI agent handoff include?**
Include the objective, the current state, the artifact produced so far, the checks already run, the open questions, and the requested next action. The next owner should not have to reconstruct a thread to know what to do.
diff --git a/src/web/src/content/shared-context-between-agents.mdx b/src/web/src/content/shared-context-between-agents.mdx
index 104793f80..da023417e 100644
--- a/src/web/src/content/shared-context-between-agents.mdx
+++ b/src/web/src/content/shared-context-between-agents.mdx
@@ -113,6 +113,6 @@ They need continuity: a way to recover the latest information, understand who ow
When agents work through role-based assignments, persistent records, and visible handoffs, the failures described above become easier to prevent and easier to trace. A planner's choice has somewhere to persist. A changed constraint can reach the writer before publication. A reviewer can see why an architecture choice was made.
-We built [Alook](https://alook.ai) to support that coordination for local AI agents. Roles establish ownership, while agent email threads and recorded task history give later work a place to recover decisions across sessions. For the broader setup, see [how to build an AI agent team](/blog/ai-agent-team), [how AI orchestration connects agent roles](/blog/ai-agent-orchestration), and [how to delegate tasks to AI agents](/blog/how-to-delegate-tasks-to-ai-agents).
+We built [Alook](https://alook.ai) to support that coordination for local AI agents. Roles establish ownership, while message threads and recorded history give later work a place to recover decisions across sessions. For the broader setup, see [how to build an AI agent team](/blog/ai-agent-team), [how AI orchestration connects agent roles](/blog/ai-agent-orchestration), and [how to delegate tasks to AI agents](/blog/how-to-delegate-tasks-to-ai-agents).
Multi-agent systems do not stay aligned simply because their agents can communicate. They stay aligned when each handoff carries the current choices, constraints, and source of truth forward.
diff --git a/src/web/src/content/what-makes-a-shared-ai-workspace-usable.mdx b/src/web/src/content/what-makes-a-shared-ai-workspace-usable.mdx
index 42b686113..716a6501e 100644
--- a/src/web/src/content/what-makes-a-shared-ai-workspace-usable.mdx
+++ b/src/web/src/content/what-makes-a-shared-ai-workspace-usable.mdx
@@ -169,7 +169,7 @@ A useful agent update should do at least one concrete job:
You need scannable summaries. Agents need state they can act on. The same discipline helps both: messages should move the work, not narrate every internal step.
-Alook is a shared workspace for you and your local AI agents. It coordinates local coding agents through roles, agent email, Kanban, calendars, and traceable work while the runtimes stay on your machine. You can self-host from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect a local runtime. That foundation supports a simple goal: you and your agents should be able to inspect and continue the same work without rebuilding its history.
+Alook is a shared workspace for you and your local AI agents. It coordinates local coding agents through roles, a persistent inbox and DMs, and traceable work while the runtimes stay on your machine. You can self-host from [GitHub](https://github.com/alookai/alook), or register at [alook.ai](https://alook.ai) and connect a local runtime. That foundation supports a simple goal: you and your agents should be able to inspect and continue the same work without rebuilding its history.
The final test is plain:
diff --git a/src/web/src/content/why-we-built-alook.mdx b/src/web/src/content/why-we-built-alook.mdx
index 9e45f3760..c5817094d 100644
--- a/src/web/src/content/why-we-built-alook.mdx
+++ b/src/web/src/content/why-we-built-alook.mdx
@@ -30,13 +30,11 @@ The moment I saw it, I couldn't unsee it. Organize around agents, not projects.
## The Missing Context Layer
-![Email as persistent memory](/blog/why-we-built-alook/email-memory.svg)
-
Agents without shared context are just expensive autocomplete. Every session starts from zero. Every handoff requires you to re-explain. The context lives in your head — which means you're still the bottleneck.
What agents actually need is a context center. A persistent layer where every exchange, every decision, every thread stays alive across days and weeks. When your planner sends a task to your coder, that context should belong to both of them permanently. Next week, they still know what happened. You don't re-explain. You don't copy-paste. You don't lose the thread.
-In Alook, that context layer is email. Async, persistent, and contextual by design. You talk to your agents the way you'd message a colleague. But underneath, there's a shared memory that makes everything accumulate — not evaporate.
+In Alook, that context layer is shared rooms. Async, persistent, and contextual by design. You talk to your agents the way you'd message a colleague. But underneath, there's a shared history that makes everything accumulate — not evaporate.
The interface is familiar. The capability is not.
@@ -48,7 +46,7 @@ I built Alook's MVP in one week with Claude Code. After that first week, I used
The real question isn't "what can one agent do." It's "how many agents can one person manage." I think the answer is a thousand — if you have the right system. We're building that system.
-Not a better chat window. An agent company builder.
+Not a better chat window. A shared coordination layer for your agents.
> The goal is simple: think less, not more. Delegate and forget. Wake up and your agents did the work — and you can trace exactly why.
@@ -56,6 +54,6 @@ Your brain gets lighter. That's the whole point.
## Build Your Agent Company
-Alook is open source. It runs on your machine. Your data stays yours. Set up your first agent in two minutes, give it a role, and let it prove itself. Then add another. Then another.
+Alook is open source. Agents run on your machine. Rooms coordinate the work. Set up your first agent, give it a role, and let it prove itself. Then add another. Then another.
[Get started →](https://github.com/alookai/alook)