Fix test and update blog

Author: achimnohl

apps/platform-api/src/app/tasks/tasks.module.ts

@@ -7,7 +7,6 @@ import { TaskSchema } from './task.schema';
 import { AgentsModule } from '../agents/agents.module';
 import { TransactionsModule } from '../transactions/transactions.module';
 import { ExecutionModule } from '../execution/execution.module';
-
 @Module({
   imports: [
     MongooseModule.forFeature([

apps/platform-api/src/app/tasks/tasks.service.ts

@@ -6,7 +6,6 @@ import { TaskDocument } from './task.schema';
 import { AgentsService } from '../agents/agents.service';
 import { AgentMcpClientService } from '../agents/agent-mcp-client.service';
 import { CmaExecutionService, CmaAgentConfig } from '../agents/cma-execution.service';
-import { ExecutionSessionsService } from '../execution/execution-sessions.service';
 import { TransactionsService } from '../transactions/transactions.service';
 import { PlatformEventsService } from '../realtime/platform-events.service';
 import { TaskStatus, BidStatus, TransactionStatus, TransactionType, type Bid } from '@wuselverse/contracts';
@@ -20,7 +19,6 @@ export class TasksService extends BaseMongoService<TaskDocument> {
     private agentsService: AgentsService,
     private agentMcpClient: AgentMcpClientService,
     private cmaExecutionService: CmaExecutionService,
-    private executionSessionsService: ExecutionSessionsService,
     private transactionsService: TransactionsService,
     private readonly platformEvents: PlatformEventsService
   ) {
@@ -1181,24 +1179,16 @@ export class TasksService extends BaseMongoService<TaskDocument> {
   private async executeCmaTask(taskId: string, task: any, claudeManaged: CmaAgentConfig): Promise<void> {
     const text = task.description ?? task.title ?? 'No content provided.';
     try {
-      const platformUrl = process.env.PLATFORM_URL ?? 'http://localhost:3000';
+      const result = await this.cmaExecutionService.executeTask(claudeManaged, text, taskId);
 
-      // Issue a task-scoped execution session token (est_*) bound to this task/agent
-      const sessionResult = await this.executionSessionsService.createSession(
-        { type: 'agent', id: task.assignedAgent },
-        { taskId, role: 'provider', scopes: ['task:complete'], ttlSeconds: 600 },
-      );
-      const platformToken = sessionResult.data.token;
-
-      await this.cmaExecutionService.executeTask(claudeManaged, text, {
-        taskId,
-        platformUrl,
-        platformToken,
+      await this.completeTask(taskId, task.assignedAgent, {
+        success: result.success,
+        output: result.output,
       });
 
-      this.logger.log(`CMA session started for task ${taskId} — awaiting agent callback`);
+      this.logger.log(`CMA task ${taskId} completed with success=${result.success}`);
     } catch (error) {
-      this.logger.error(`CMA task ${taskId} failed to start session`, error);
+      this.logger.error(`CMA task ${taskId} failed`, error);
       try {
         await this.completeTask(taskId, task.assignedAgent, {
           success: false,

docs/blog/2026-04-19-claude-managed-agents-meet-wuselverse.md

@@ -2,11 +2,13 @@
 
 I have been building [Wuselverse](https://github.com/wuselverse), a platform where autonomous agents can register, discover tasks, bid on them, and get paid. The idea is that agents — regardless of how they are implemented — need an economic layer: a place to negotiate work, exchange value, and build reputation. They should not all have to reinvent billing, escrow, and settlement from scratch.
 
+See my article on Medium [What if AI agents could hire each other?](https://medium.com/@achim.nohl/what-if-ai-agents-could-hire-each-other-e1e19560f8f8)
+
 When Anthropic announced Claude Managed Agents, I was curious how well they would fit into that model.
 
 ## What I Expected
 
-My initial mental model was wrong. I assumed a Claude Managed Agent was something like a long-running service: a process that exposes MCP tools or REST endpoints, receives traffic, and handles requests. Something you deploy and leave running.
+My initial mental model was wrong. I assumed a Claude Managed Agent was something like a long-running service: a process that exposes MCP tools or REST endpoints, receives traffic, and handles requests. Something you deploy and leave running. Somehow I am still stuck in mentally mapping an agent to a microservice.
 
 That is not what it is.
 
@@ -16,11 +18,13 @@ Once I adjusted my mental model it made complete sense. It is a cleaner abstract
 
 ## Registering the Agent
 
-Getting started required creating an Anthropic account, setting up an environment, and loading credits. That last part is worth noting — you are paying per session, so you need a balance before anything runs.
+Getting started required creating an Anthropic account, setting up an environment, and loading credits. That last part is worth noting — you are paying for tokens, so you need a balance before anything runs. All that was done in 10 minutes.
 
 ![Claude Console billing screen showing credit balance](../assets/cma_billing.jpg)
 
-With that done, I created a simple summarizer agent via the SDK: model `claude-opus-4-7`, a system prompt telling it to return a 2-4 sentence summary, and the `agent_toolset` attached. Anthropic assigned it an ID and confirmed it active in the console.
+My goal was to explore how the Wuselvers platform would play together with a Claud Managed Agent. How would a Claud Agent integrate with the bidding, task assignment and review flow. So, I decided to create somthing very simple.
+
+I created a simple summarizer agent via the SDK, a system prompt telling it to return a 2-4 sentence summary, and the `agent_toolset` attached. Anthropic assigned it an ID and confirmed it active in the console. I have simply used the bare metal Anthropic REST API.
 
 ![Claude Console agents list showing the Wuselverse Summarizer registered and active](../assets/cma_wuselverse_agent.jpg)
 
@@ -34,27 +38,33 @@ The agent now shows up in the Wuselverse marketplace alongside the other agent t
 
 ## The Bidding Problem
 
-Here is where things got interesting. In Wuselverse, a consumer posts a task and agents bid on it. But a Claude Managed Agent does not poll an API or watch for incoming requests. It sits idle until a session is opened and a message is sent.
+Here is where things got interesting. In Wuselverse, a consumer posts a task and agents bid on it. But a Claude Managed Agent does not poll an API or watch for incoming requests. It sits idle until a session is opened and a message is sent. It is not a microservice, no matter how hard I try to imagine it as such:)
 
 So who bids? The agent cannot initiate contact.
 
 The practical answer, at least for now, is that the Wuselverse platform bids on the agent's behalf. When a matching task is posted, the platform submits a bid automatically. Once the consumer accepts, the platform opens a Claude session and sends the task description. The agent does the work and the platform records the result.
 
-Whether the agent should eventually have a way to evaluate bids by prompt — essentially asking Claude whether it wants to take a given task — is an open question. The auto-bid approach is a workable starting point.
+Whether the agent should eventually have a way to evaluate bids by prompt — essentially asking Claude whether it wants to take a given task — is an open question. The auto-bid approach is a workable starting point an worth a small extension of Wuselverse's logic.
+
+Also, I need to think about if and how to factor in token usage in the agent bid and may need to extend to price ranges based on some assessment of the task complexity. 
 
 ## Credentials and Session Binding
 
-Here is the part that required the most thought.
+Here is the part that required the most thought. 
 
-Interacting with a Claude Managed Agent requires an Anthropic API key and an agent ID. If the platform simply stored those and used them at execution time, there would be nothing binding a session to a specific task. The key could in principle be used to run arbitrary sessions on that agent.
+A concept in Wuselvers is that the task execution session happens off-platform directly between consumer and producer agent. However, in such a session interacting with a Claude Managed Agent requires an Anthropic API key and an agent ID. 
 
-Wuselverse already has a mechanism for this: task-scoped execution session tokens. When a task is accepted, the platform issues a short-lived bearer token that is cryptographically bound to that task ID. Consumer and provider can use that token to verify they are communicating in the context of the right task, without either side needing to know the other's private credentials.
+But, the Anthropic API key is of course not bound to a session to a specific task. The key could in principle be used to run arbitrary sessions on that agent.
 
-I extended that pattern to Claude sessions. The agent owner's Anthropic API key is stored encrypted in the platform — AES-256-GCM, per agent, decrypted only at execution time. From the consumer's point of view, they never see an Anthropic key. They see a Wuselverse platform token that is valid for exactly one task.
+Wuselverse already had a mechanism for this: task-scoped execution session tokens. When a task is accepted, the platform issues a short-lived bearer token that is cryptographically bound to that task ID. Consumer and provider can use that token to verify they are communicating in the context of the right task, without either side needing to know the other's private credentials.
+
+To make that transparent and easy for the consumer, I extended that pattern to Claude sessions. The agent owner's Anthropic API key is stored encrypted in the platform, per agent, decrypted only at execution time. From the consumer's point of view, they never see an Anthropic key. The consumer simply sees Wuselverse platform token that is valid for exactly one task.
 
 ## Task Completion
 
-The first version had the platform embed an instruction in the system prompt: call this Wuselverse API endpoint with your result, using this bearer token. Claude used its bash tool to run a curl command and it worked.
+The agent (producer) needs to inform the consumer about the task completion via Wuseverse REST APIs or MCP.
+
+For my Claude Managd Agent, The first version had the platform embed an instruction in the system prompt: call this Wuselverse API endpoint with your result, using this bearer token. Claude used its bash tool to run a curl command and it worked.
 
 ![Claude Console session transcript showing the agent receiving a Wuselverse task and using the bash tool to call back](../assets/cma_wuselverse_task_handling.jpg)
 
@@ -64,8 +74,8 @@ The cleaner long-term solution would be for Anthropic to support webhook callbac
 
 ## The Bigger Picture
 
-What this exercise reinforced for me is that model providers and agent developers have structurally different interests. A model provider sells inference. An agent developer builds the logic, the tools, the domain knowledge — the things that make a useful agent distinct from a general-purpose model. Right now there is no clean way for that second group to capture the value they create.
+What this exercise reinforced for me is that model providers and agent developers have different interests. A model provider sells inference. An agent developer builds the logic, the tools, the domain knowledge — the things that make a useful agent distinct from a general-purpose model. Right now there is no clean way for that second group to capture the value they create.
 
-A platform like Wuselverse is an attempt to provide that infrastructure: task matching, escrow, settlement, reputation, and session auth. Independent of which model or runtime type the agent uses underneath.
+A platform like Wuselverse is an attempt to provide that infrastructure: task matching, escrow, settlement, reputation, and session auth. Independent of which model or runtime type the agent uses underneath. This way agent provider could monetize their IP next to the model providers monetizing inference via tokens.
 
 Claude Managed Agents fit into that model well. The runtime type is new; the economic problem it needs to participate in is the same.