@lov3kaizen/agentsea-crews 1.0.1 → 1.1.1

package/README.md

@@ -70,6 +70,32 @@ const result = await crew.kickoff();
 console.log(result.finalOutput);
 ```
 
+> **Execution model.** By default, crew agents execute against real LLMs via
+> `@lov3kaizen/agentsea-core` providers (a required peer dependency), so make
+> sure the relevant API key is set (e.g. `ANTHROPIC_API_KEY`). Supported
+> providers out of the box: `anthropic`, `openai`, `gemini`, `ollama`.
+>
+> - To plug in a different integration, pass an `execute` function on the crew
+>   config (or to `createCrewAgent`).
+> - For offline scaffolding and tests, set `mock: true` on the crew config to
+>   get deterministic mock responses without any network calls.
+>
+> ```typescript
+> // Offline / test mode
+> const crew = createCrew({ ...config, mock: true });
+>
+> // Custom execution backend
+> const crew2 = createCrew({
+>   ...config,
+>   execute: async (input, systemPrompt) => ({
+>     output: await myLlm(systemPrompt, input),
+>     tokensUsed: 0,
+>     latencyMs: 0,
+>     iterations: 1,
+>   }),
+> });
+> ```
+
 ### Using Templates
 
 ```typescript
@@ -154,6 +180,36 @@ const crew = createCrew({
 });
 ```
 
+### Concurrency
+
+By default a crew runs ready tasks **sequentially**, which keeps event ordering
+deterministic. For independent tasks you can opt into a bounded worker pool so
+they execute in parallel — set it on the crew config or per `kickoff()` call:
+
+```typescript
+// Crew-wide default
+const crew = new Crew({
+  name: 'Research Crew',
+  agents: [...],
+  delegationStrategy: 'best-match',
+  maxConcurrentTasks: 4, // up to 4 ready tasks run at once
+});
+
+// Or override per run (takes precedence over the config value)
+const result = await crew.kickoff({ maxConcurrentTasks: 4 });
+```
+
+Notes:
+
+- The default is `1` (fully sequential) — behavior is unchanged unless you opt in.
+- Only tasks that are _ready_ in the same scheduling iteration run together, so
+  dependency ordering is still respected.
+- With concurrency `> 1`, `task:assigned` / `task:completed` events from
+  different tasks interleave as workers settle (each task still emits its own
+  events in order). If a task fails after exhausting retries, no further tasks
+  are launched, in-flight tasks are allowed to settle, and the crew ends with the
+  same fatal `crew:error` as the sequential path.
+
 ### Memory Systems
 
 Share state and knowledge across agents: