Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

blog: refresh GSC priority posts (FAQ + dateModified) (#438)

LindsayLiu777b1b29d78b067
diff --git a/src/app/test/services.test.ts b/src/app/test/services.test.ts
index 8515926fc..19958e0fd 100644
--- a/src/app/test/services.test.ts
+++ b/src/app/test/services.test.ts
@@ -1,5 +1,5 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, existsSync, rmSync, writeFileSync } from "fs";
+import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from "vitest";
+import { mkdirSync, existsSync, rmSync } from "fs";
import { join } from "path";
import { tmpdir } from "os";
@@ -13,6 +13,15 @@ vi.mock("../src/lib/constants.js", () => ({
}));
describe("services", () => {
+ // Windows CI can spend >15s on the cold Vitest transform of services.ts
+ // (pulls @alook/shared). Warm the graph once so per-test dynamic imports
+ // hit the transform cache instead of timing out.
+ beforeAll(async () => {
+ await import("../src/lib/pid.js");
+ await import("../src/lib/services.js");
+ vi.resetModules();
+ }, 60_000);
+
beforeEach(() => {
mkdirSync(testDir, { recursive: true });
});
@@ -28,7 +37,7 @@ describe("services", () => {
it("returns false when no pid file exists", async () => {
const { isRunning } = await import("../src/lib/services.js");
expect(isRunning()).toBe(false);
- }, 15_000);
+ });
it("returns false when all pids are dead", async () => {
const { writePids } = await import("../src/lib/pid.js");
diff --git a/src/web/src/content/ai-agent-orchestration.mdx b/src/web/src/content/ai-agent-orchestration.mdx
index ce1b4aa01..c55bbbd6b 100644
--- a/src/web/src/content/ai-agent-orchestration.mdx
+++ b/src/web/src/content/ai-agent-orchestration.mdx
@@ -2,10 +2,11 @@ export const metadata = {
slug: "ai-agent-orchestration",
title: "AI Orchestration: How Multiple Agents Work Together",
date: "2026-06-03",
+ dateModified: "2026-08-10",
author: "Alook Team",
excerpt:
- "AI orchestration coordinates specialized agents through roles, handoffs, retries, and shared context. It covers first workflows and build-vs-buy tradeoffs.",
- readingTime: "5 min read",
+ "AI orchestration (agent coordination) routes specialized agents with roles, handoffs, retries, and shared context.",
+ readingTime: "6 min read",
image: "/blog/ai-agent-orchestration/hero.webp",
};
@@ -14,6 +15,30 @@ export const jsonLd = [
"@context": "https://schema.org",
"@type": "FAQPage",
mainEntity: [
+ {
+ "@type": "Question",
+ name: "What is AI agent orchestration?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "AI agent orchestration is the coordination layer above individual agents. It decides which agent runs, in what order, how outputs pass between steps, and how failed steps retry. People also call this AI agent coordination when the emphasis is on keeping multi-agent work aligned.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "What is agent orchestration?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Agent orchestration is the same idea without the marketing prefix: a system that assigns roles, sequences steps, and moves results between agents so a multi-step job can finish without a person forwarding every message.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do I orchestrate multiple checks in one user flow?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Split the flow into named checks owned by specialized agents or steps, define the order and what each check returns, then let the orchestration layer pass results forward and retry a failed check without restarting the whole flow. Keep human approval for irreversible actions after the checks pass.",
+ },
+ },
{
"@type": "Question",
name: "AI orchestration vs automation: what's the difference?",
@@ -27,7 +52,7 @@ export const jsonLd = [
name: "Do you need to write code for AI orchestration?",
acceptedAnswer: {
"@type": "Answer",
- text: "Not necessarily. Building your own orchestration means writing code. A no-code platform lets you describe roles in plain language and skip the plumbing.",
+ text: "Not necessarily. Building your own orchestration means writing code. A platform can let you describe roles and sequences while it handles queues, retries, and state.",
},
},
{
@@ -44,16 +69,18 @@ export const jsonLd = [
![Hand-drawn diagram of AI orchestration as a coordination layer connecting data, analysis, writing, and delivery agents around a shared goal](/blog/ai-agent-orchestration/hero.webp)
-AI orchestration is how you get multiple AI agents to finish a task together, each handling one step, without you moving work between them by hand. One agent does step one. Another picks up step two. A third closes it out. You set it up once, then stay out of the loop.
+**AI agent orchestration** is how multiple specialized agents finish one job together: who runs, in what order, what each step returns, and how a failed step retries, without you forwarding every message. Teams also search for **AI agent coordination** when they mean the same layer.
-Think about the last time you copied data from one tool, pasted it into a chat model, then copied the summary into an email. AI orchestration removes you from that chain. Instead of one model trying to do everything, an orchestration layer coordinates specialized agents and passes work from one to the next.
+One agent does step one. Another picks up step two. A third closes it out. You set the roles once. The orchestration layer keeps the work moving.
## What is AI orchestration?
-AI orchestration is the coordination layer that sits above your individual agents. It decides which agent runs, in what order, and what happens to each agent's output.
+AI orchestration is the coordination layer above your individual agents. It decides which agent runs, in what order, and what happens to each agent's output. **Agent orchestration** is the same idea stated without the “AI” prefix.
A single agent answers one prompt at a time. Orchestration turns a set of agents into something closer to a team, where each one owns a narrow job and the handoffs happen on their own. You describe the roles and the sequence. The layer keeps the work flowing.
+For named pattern catalogs (fan-out, review gates, and similar), see [multi-agent workflow patterns](/blog/multi-agent-workflow-patterns). This page stays on the coordination layer itself.
+
## Why one agent isn't enough
You can ask one capable model to handle a long, multi-step job. It tends to break down in predictable ways.
@@ -77,6 +104,20 @@ Multi-agent workflow automation is a fixed AI workflow where each agent owns one
Get this right and the AI workflow runs on schedule whether you show up or not. For building a full [AI team](/blog/ai-agent-team) around these workflows, start by defining the roles.
+
+## How do I orchestrate multiple checks in one user flow?
+
+Treat each check as a named step with a clear owner and return shape.
+
+Example shape for a coding or product flow:
+
+1. **Auth check** — confirm the actor may run the flow
+2. **Input validation** — reject bad payloads early
+3. **Business rule check** — apply the domain constraints
+4. **Side-effect gate** — prepare writes, wait for approval if needed
+
+Orchestration runs those steps in order, passes structured results forward, and retries a failed check without restarting the whole flow. Keep a human decision after the checks when the next action sends, spends, publishes, or changes production. For Claude Code and Codex as peer runtimes on the same repo, see [Claude Code and Codex on the same team](/blog/claude-code-and-codex-same-team).
+
## What to orchestrate first
Not every task is a good fit. Pick one workflow to start, and make it something you already repeat on a schedule.
@@ -110,11 +151,20 @@ The future of this work isn't one super-intelligent model doing everything. It's
## AI orchestration FAQ
+**What is AI agent orchestration?**
+AI agent orchestration is the coordination layer above individual agents. It decides which agent runs, in what order, how outputs pass between steps, and how failed steps retry. **AI agent coordination** usually points at the same job.
+
+**What is agent orchestration?**
+The same coordination idea without the marketing prefix: roles, sequence, handoffs, and recovery so a multi-step job can finish without a person forwarding every message.
+
+**How do I orchestrate multiple checks in one user flow?**
+Split the flow into named checks, define order and return values, let the layer pass results and retry failures, and keep human approval for irreversible actions after the checks pass.
+
**AI orchestration vs automation: what's the difference?**
Automation runs a single task on a trigger. Orchestration coordinates several agents across a multi-step task, deciding order, handoffs, and recovery. Multi-agent workflow automation is what you get when the two combine.
**Do you need to write code?**
-Not necessarily. Building your own orchestration means writing code. A no-code platform lets you describe roles in plain language and skip the plumbing.
+Not necessarily. Building your own orchestration means writing code. A platform can let you describe roles and sequences while it handles queues, retries, and state.
**When is orchestration overkill?**
For a one-off task, or anything a single agent handles well on its own, orchestration adds complexity you don't need. It pays off when work is repetitive, multi-step, and runs on a schedule.
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 a028531f3..6ee849a6e 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
@@ -2,6 +2,7 @@ export const metadata = {
slug: "claude-code-and-codex-same-team",
title: "How to Bring Claude Code and Codex Into the Same Team",
date: "2026-07-22",
+ dateModified: "2026-08-10",
author: "Alook Team",
excerpt:
"Use Claude Code and Codex as one coordinated team. Roles, handoffs, shared status, and a coordination layer that connects separate coding-agent sessions.",
@@ -16,6 +17,46 @@ export const jsonLd = [
"@context": "https://schema.org",
"@type": "FAQPage",
mainEntity: [
+ {
+ "@type": "Question",
+ name: "Can you use Claude Code and Codex together?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Yes. You can run both against the same repository and assign different jobs, such as implementation and review. They do not share one session by default, so you still need roles, structured handoffs, and a place to see status across runtimes.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do you combine Codex and Claude Code?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Give each runtime a stable role, move code through Git, and pass a handoff package with objective, branch or commit, decisions, checks run, and the next action. A coordination layer helps when those handoffs must survive closed CLI sessions.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do you make Claude Code and Codex talk to each other?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "They do not automatically share chat history. Connect them through pull requests, shared task records, or addressable agent inboxes so review findings and implementation updates land with the owner of the next step.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "Claude or Codex?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Choose based on the job, subscriptions, and repository habits, not a universal winner. Many teams keep both and split roles, for example one runtime implements while the other reviews.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "What is a Claude Code handoff to Codex?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "A handoff is a structured package the next runtime can act on: objective, branch or commit, files changed, decisions made, checks already run, open questions, and the requested next action. Git alone rarely carries all of that.",
+ },
+ },
{
"@type": "Question",
name: "Can Claude Code and Codex work on the same repository?",
@@ -54,11 +95,9 @@ export const jsonLd = [
![Illustration of two separate coding-agent runtimes (Builder and Reviewer) connected by a gold coordination layer with handoffs and human merge approval](/blog/claude-code-and-codex-same-team/hero.webp)
-You might use Claude Code to implement a feature and Codex to review the diff. Or the other way around.
-
-The friction shows up when a task has to cross from one runtime into the other. Each session has its own context, its own threads, and its own agent model. Unless you design for handoffs, you become the hidden router between them.
+Yes, you can use Claude Code and Codex together on the same repository. They will not share one brain or one chat history. Turning them into one team means stable roles, structured handoffs, shared status, and a human approval boundary for merge and release.
-Running two agent systems is easy. Turning them into one persistent team takes roles, structured handoffs, shared visibility, and clear human approval boundaries.
+You might use Claude Code to implement a feature and Codex to review the diff. Or the other way around. The friction shows up when work has to cross from one runtime into the other. Unless you design for that crossing, you become the hidden router between sessions.
## Why two AI agent systems are not automatically one team
@@ -247,6 +286,29 @@ Alook is a coordination layer, not a merged IDE. You still maintain two runtimes
To explore templates and roles, see [Alook templates](https://alook.ai/templates). For broader team design, see [how to build an AI agent team](/blog/ai-agent-team) and [how to delegate tasks to AI agents](/blog/how-to-delegate-tasks-to-ai-agents).
+
+## Claude Code and Codex FAQ
+
+### Can you use Claude Code and Codex together?
+
+Yes. Run both against the same repo and give each a job. The missing piece is usually coordination: who acts next, which decision is current, and how review findings return without you pasting between terminals.
+
+### How do you combine Codex and Claude Code?
+
+Assign stable roles, move code through Git, and pass a handoff package the next runtime can use. When those handoffs must survive closed sessions, add a coordination layer with identities, threads, and task visibility. For broader team design, see [how to build an AI agent team](/blog/ai-agent-team) and [how to delegate tasks to AI agents](/blog/how-to-delegate-tasks-to-ai-agents).
+
+### How do you make Claude Code and Codex talk to each other?
+
+They do not auto-sync chat. Connect them through pull requests, shared task records, or addressable agent messages so the owner of the next step receives the update.
+
+### Claude or Codex?
+
+There is no universal winner. Pick by job, subscription, and habit. Many teams keep both and split implementation from review rather than forcing every task into one runtime.
+
+### What is a Claude Code handoff to Codex?
+
+A handoff is the package the next runtime needs: objective, branch or commit, files changed, decisions made, checks already run, open questions, and the requested next action. Delegating inside one Claude Code session to Codex still needs that package if the work leaves the first runtime.
+
## When keeping them separate is simpler
You may not need a cross-runtime team yet.
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 143d52997..9b551362c 100644
--- a/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx
+++ b/src/web/src/content/claude-code-dynamic-workflow-alternative.mdx
@@ -1,18 +1,20 @@
export const metadata = {
slug: "claude-code-dynamic-workflow-alternative",
- title: "Open Source Alternative to Claude Code Dynamic Workflow: Email-Based Agent Coordination",
+ title: "OpenCode Dynamic Workflow: Claude Code vs Email Coordination",
date: "2026-06-01",
+ dateModified: "2026-08-10",
author: "Alook Team",
excerpt:
- "Claude Code dynamic workflows suit one-shot parallel tasks. Email-based agent coordination adds persistent context, multi-day handoffs, and team visibility.",
+ "OpenCode dynamic workflow needs often mean durable coordination. Claude Code stays in-session; email coordination spans OpenCode, Codex, and Claude Code.",
readingTime: "4 min read",
+ image: "/blog/claude-code-dynamic-workflow-alternative/seo-team.png",
};
-Claude Code shipped dynamic workflows last week. Write JavaScript, run 100+ agents, keep working.
+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.
-Great if you stay in one Claude Code session and work alone.
+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.
-We built something different at Alook because we needed agents that remember things tomorrow and can hand off work to teammates. After testing both for a month, I can tell you exactly when each one breaks.
+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.
## Dynamic Workflows Do One Thing Really Well
@@ -31,15 +33,21 @@ Launch 50 to 500 agents at once. They all run in parallel while you keep working
## Then You End the Session
-I audited a codebase with dynamic workflows. Spent $47 in tokens, saved six hours of manual work. Great trade.
+A large dynamic-workflow run can still be a good trade for a one-shot audit. The limit shows up the next day.
-Next day I wanted to run it again with a small change. I had to start from scratch because exiting Claude Code ended the session. Resume works within the same session — completed agents return cached results when you pause and resume from `/workflows` — but a new session starts the workflow fresh. I tried to hand it to a colleague who handles our security reviews. Couldn't. The run was tied to my session.
+Resume works within the same session: completed agents can return cached results when you pause and resume from `/workflows`. A new session starts the workflow fresh. You cannot hand the live run to a teammate as a shared, ongoing job. The work stays tied to that Claude Code session.
-Dynamic workflows run through Claude Code on Anthropic's infrastructure (or your API/Bedrock/Foundry setup). They require a paid Claude plan, API access, or an equivalent hosted integration — not a single $20 Pro tier alone.
+Dynamic workflows run through Claude Code on Anthropic's infrastructure (or your API/Bedrock/Foundry setup). They require a paid Claude plan, API access, or an equivalent hosted integration. A single low-tier consumer plan alone is often not enough for this class of run.
-## We Went with Email Instead
+## OpenCode dynamic workflow vs Claude Code dynamic workflows
-Sounds primitive. Agents literally email each other. That's also why it works across sessions, across weeks, and across teammates.
+**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.
+
+## We went with email instead
+
+Sounds primitive. Agents literally email each other. 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.
@@ -61,9 +69,9 @@ Each agent has a separate workspace. No shared state bugs. Everything logs to `.
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 remember. Vera references keyword research from two weeks ago. Oralla knows which deployment patterns worked. Kai tracks trends across months. Try keeping that context alive in one browser tab.
+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.
-May numbers: 3 articles live, 173 impressions, 41 clicks, 23.70% CTR. Not massive but real. System logged 87 tasks over 18 days. Each one searchable.
+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.
## When Each One Wins
@@ -80,7 +88,7 @@ May numbers: 3 articles live, 173 impressions, 41 clicks, 23.70% CTR. Not massiv
## Audit 500 Files or Run a Program?
-Need to check 500 API endpoints for auth bugs? Dynamic workflow. Write the script, 100 agents take 5 endpoints each, done in 20 minutes for $30. Manual would take two days.
+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.
@@ -109,25 +117,26 @@ Donia emails the right agent. You see it happen in the activity feed.
![Email activity feed](/blog/claude-code-dynamic-workflow-alternative/email-inbox.png)
-Real workflow from last week:
-- Me: "Write API rate limiting best practices post"
+Illustrative handoff shape:
+
+- You: "Write API rate limiting best practices post"
- Donia → Rosanna: "Research rate limiting approaches"
-- Rosanna → Donia: "Found 5 patterns with tradeoffs" (3 hours later)
+- Rosanna → Donia: "Found patterns with tradeoffs" (hours later)
- Donia → Vera: "Write post from attached research"
-- Vera → Donia: "Draft attached, 1,200 words" (next morning)
-- Donia → Me: "Post ready for review"
+- Vera → Donia: "Draft attached" (next morning)
+- Donia → you: "Post ready for review"
-Everything saved. Search it later. Agents reference it next time.
+Everything saved. Search it later. Agents can reference it next time.
-## I Ran the Same Audit Both Ways
+## Same job, two coordination styles
-Security audit of our auth system.
+Suppose you need a security pass over an auth surface.
-Dynamic workflow: 5 minutes writing JavaScript. 100 agents, 18 minutes runtime. $31. Complete coverage report.
+**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: 10 minutes explaining the task. One agent, 4 hours (I did other work). $8. Found fewer issues but explained each one. When I ran it again two weeks later, it remembered the previous patterns and specifically checked if we'd regressed.
+**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.
-Speed isn't the difference. Coverage versus understanding is.
+Speed is not the only difference. Coverage versus durable understanding is.
## You Probably Want Both
@@ -135,6 +144,6 @@ Claude Code dynamic workflows demolish single-session parallel work. Migrations,
Email 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 coordination to run our product team. When someone needs to audit 500 files, they trigger a dynamic workflow. Results come back through email for the next person.
+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.
**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)
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 0ce998c2d..afebc2fc2 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
@@ -2,9 +2,10 @@ export const metadata = {
slug: "how-to-delegate-tasks-to-ai-agents",
title: "How to Delegate Tasks to AI Agents",
date: "2026-06-03",
+ dateModified: "2026-08-10",
author: "Alook Team",
excerpt:
- "Delegate tasks to AI agents with a five-step method for choosing stable work, writing instructions, supervising early runs, and setting review boundaries.",
+ "Delegate tasks to AI agents with a clear method for stable work, multi-day coding jobs, authority boundaries, supervised runs, and human review.",
readingTime: "7 min read",
image: "/blog/how-to-delegate-tasks-to-ai-agents/hero.webp",
};
@@ -22,6 +23,22 @@ export const jsonLd = [
text: "Pick one stable, repeatable task. Write instructions with inputs, steps, output format, and stop conditions. Run the agent supervised until the output is reliable, then keep a review boundary for high-impact actions.",
},
},
+ {
+ "@type": "Question",
+ name: "What's the best way to delegate a multi-day coding task to an AI agent?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Break the job into daily or checkpoint-sized slices with a written definition of done for each slice. Carry branch, decisions, and open questions in a durable handoff. Review at each checkpoint. Keep merge, release, and customer-facing changes behind a human.",
+ },
+ },
+ {
+ "@type": "Question",
+ name: "How do you delegate user authority to AI agents?",
+ acceptedAnswer: {
+ "@type": "Answer",
+ text: "Separate addressing from authority. Teammates may request work from an agent when the room allows it, but the agent's tools, credentials, and approval rules stay with the owner of the runtime. A request should never silently expand what the agent can do.",
+ },
+ },
{
"@type": "Question",
name: "What makes a task good for AI agent delegation?",
@@ -199,6 +216,23 @@ Keep a person in the path for:
Agents can prepare the work. People should still own irreversible decisions.
+## What's the best way to delegate a multi-day coding task to an AI agent?
+
+Do not hand over a week of work as one vague prompt. Slice it.
+
+- Write a definition of done for **today’s slice**, not the whole epic
+- End each day with branch or commit, decisions made, checks run, and open questions
+- Start the next day from that package, not from memory
+- Schedule a human checkpoint before merge, release, or API changes
+
+Multi-day work fails when the agent optimizes for activity instead of checkpoints. Approvals, exceptions, and handoffs to people belong in the stop conditions. For team-level operating rules, see [how to run an AI agent team that stays on track](/blog/run-ai-agent-team-that-stays-on-track).
+
+## How do you delegate user authority to AI agents?
+
+**Addressing** is who may ask an agent for work. **Authority** is what the agent is allowed to do with tools and credentials.
+
+A teammate can @mention your agent in a shared room without inheriting your local secrets. The request does not expand permissions. The agent may answer, draft, refuse, or ask you to approve. Keep owner-defined tools and approval boundaries intact. The room-protocol view of that split is in [humans and AI agents in one room](/blog/humans-and-ai-agents-in-one-room).
+
## Instruction patterns that hold up
Strong instructions usually include:
@@ -247,6 +281,14 @@ If any answer is fuzzy, keep the task with a human for one more cycle.
Pick one stable, repeatable task. Write instructions with inputs, steps, output format, and stop conditions. Run the agent supervised until the output is reliable, then keep a review boundary for high-impact actions.
+**What's the best way to delegate a multi-day coding task to an AI agent?**
+
+Break the job into checkpoint-sized slices with a written definition of done for each slice. Carry branch, decisions, and open questions forward. Review at each checkpoint. Keep merge and release behind a human.
+
+**How do you delegate user authority to AI agents?**
+
+Separate addressing from authority. Others may request work when the room allows it; tools, credentials, and approvals stay with the runtime owner. A request should not silently expand what the agent can do.
+
**What makes a task good for AI agent delegation?**
A good task has a clear trigger, known inputs, a recognizable output, few judgment calls, and a safe place to pause when information is missing. Vague goals and taste-heavy work are poor first candidates.