feat(agent): drop the integrations sub-agent — search and call connected actions directly

app/src/utils/__tests__/toolTimelineFormatting.test.ts

@@ -68,43 +68,23 @@ describe('formatTimelineEntry', () => {
     });
   });
 
-  it('formats delegate_to_integrations_agent with a known toolkit arg', () => {
+  it('labels a direct connected-service action by its provider', () => {
     expect(
       formatTimelineEntry(
-        entry({
-          name: 'delegate_to_integrations_agent',
-          argsBuffer: JSON.stringify({
-            toolkit: 'gmail',
-            prompt: 'Find the latest invoice from Stripe.',
-          }),
-        })
+        entry({ name: 'GMAIL_SEND_EMAIL', argsBuffer: JSON.stringify({ to: 'alex@example.com' }) })
       )
-    ).toEqual({
-      title: 'Making requests to your Gmail account',
-      detail: 'Find the latest invoice from Stripe.',
+    ).toEqual({ title: 'Making requests to your Gmail account', detail: 'Send email' });
+    expect(formatTimelineEntry(entry({ name: 'GOOGLE_CALENDAR_CREATE_EVENT' }))).toEqual({
+      title: 'Updating your Google Calendar',
+      detail: 'Create event',
     });
   });
 
-  it('formats delegate_to_integrations_agent with an unknown toolkit arg', () => {
-    expect(
-      formatTimelineEntry(
-        entry({
-          name: 'delegate_to_integrations_agent',
-          argsBuffer: JSON.stringify({ toolkit: 'slack_bot', prompt: 'post update' }),
-        })
-      )
-    ).toEqual({ title: 'Checking your Slack Bot', detail: 'post update' });
-  });
-
-  it('formats delegate_to_integrations_agent without a toolkit arg as a generic connected-app label', () => {
-    expect(
-      formatTimelineEntry(
-        entry({
-          name: 'delegate_to_integrations_agent',
-          argsBuffer: JSON.stringify({ prompt: 'do something useful' }),
-        })
-      )
-    ).toEqual({ title: 'Checking your connected app', detail: 'do something useful' });
+  it('keeps the generic label for upper-case names on unknown toolkits', () => {
+    expect(formatTimelineEntry(entry({ name: 'STRIPE_LIST_CHARGES' }))).toEqual({
+      title: 'STRIPE LIST CHARGES',
+      detail: undefined,
+    });
   });
 
   it('formats delegate_tools_agent with toolkit context from args', () => {
@@ -402,7 +382,6 @@ describe('isKnownClientTool', () => {
     expect(isKnownClientTool('file_read')).toBe(true);
     expect(isKnownClientTool('shell')).toBe(true);
     expect(isKnownClientTool('subagent:researcher')).toBe(true);
-    expect(isKnownClientTool('delegate_to_integrations_agent')).toBe(true);
     // The streamed search-slot name, so the client label wins over the
     // server's humanized "Web Search Tool".
     expect(isKnownClientTool('web_search_tool')).toBe(true);

app/src/utils/toolTimelineFormatting.ts

@@ -311,21 +311,23 @@ export function formatTimelineEntry(entry: ToolTimelineEntry): { title: string;
       inferIntegrationNameFromPrompt(parsedArgs?.prompt) ??
       inferIntegrationName(entry.name);
 
-    let title: string;
-    if (provider) {
-      title = integrationActivityTitle(provider);
-    } else if (entry.name === 'delegate_to_integrations_agent') {
-      const rawToolkit = parsedArgs?.toolkit?.trim();
-      title = rawToolkit
-        ? integrationActivityTitle(humanizeIdentifier(rawToolkit))
-        : 'Checking your connected app';
-    } else {
-      title = humanizeIdentifier(entry.name);
-    }
-
+    const title = provider ? integrationActivityTitle(provider) : humanizeIdentifier(entry.name);
     return { title, detail: entry.detail ?? parsedArgs?.prompt };
   }
 
+  // A connected-service action called directly (`GMAIL_SEND_EMAIL`,
+  // `SLACK_SEND_MESSAGE`): the orchestrator finds these through
+  // `tool_search` and calls them itself, so this is the row a user sees
+  // for "send that email". Label it by the service, with the action as
+  // the detail, rather than a raw humanised slug.
+  const directAction = inferIntegrationActionName(entry.name);
+  if (directAction) {
+    return {
+      title: integrationActivityTitle(directAction.provider),
+      detail: entry.detail ?? directAction.action,
+    };
+  }
+
   // ── Tool-specific formatting with args-derived detail ──────────────
   // Pass the completed result text so args-aware formatters can surface
   // details only known post-execution (e.g. the resolved search provider).
@@ -646,6 +648,32 @@ function inferIntegrationName(input?: string): string | undefined {
   return undefined;
 }
 
+/**
+ * Split a Composio action slug (`GMAIL_SEND_EMAIL`) into its known provider
+ * and a readable action ("Send email"). `undefined` for anything that is not
+ * an upper-case `<TOOLKIT>_<ACTION>` name on a known toolkit, so ordinary
+ * tools and unknown toolkits keep their generic label.
+ */
+function inferIntegrationActionName(
+  name: string
+): { provider: string; action: string } | undefined {
+  if (!/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/.test(name)) return undefined;
+  // Try the longest toolkit prefix first (`GOOGLE_CALENDAR_...`), then the
+  // shortest (`GMAIL_...`).
+  const parts = name.split('_');
+  for (let i = Math.min(parts.length - 1, 2); i >= 1; i -= 1) {
+    const toolkit = parts.slice(0, i).join('_');
+    if (KNOWN_TOOLKIT_RE.test(toolkit)) {
+      const action = parts.slice(i).join(' ').toLowerCase();
+      return {
+        provider: normalizeIntegrationName(toolkit),
+        action: action.charAt(0).toUpperCase() + action.slice(1),
+      };
+    }
+  }
+  return undefined;
+}
+
 function integrationActivityTitle(provider: string): string {
   switch (provider) {
     case 'GitHub':

crates/openhuman-app/src/lib.rs

@@ -2370,8 +2370,9 @@ pub fn run() {
     // `core_process::CoreProcessHandle::ensure_running` via
     // `tokio::spawn(run_server_embedded(..))`) runs *on* that runtime, so
     // every JSON-RPC handler — including the deep tower
-    // `web channel chat → orchestrator turn → delegate_to_integrations_agent
-    // → sub-agent → composio_list_tools → load_config_with_timeout` —
+    // `web channel chat → orchestrator turn → integration action tool
+    // → composio execute → load_config_with_timeout` (and, at the time, the
+    // now-removed integrations sub-agent spawn in between) —
     // burns through the same 2 MB. In `crahs.log` (2026-05-17, build
     // 0.53.49) that tower plus the serde-monomorphised `Config` Visitor
     // frames pushed past the guard page and aborted with

crates/openhuman-core/src/agent/bus.rs

@@ -114,9 +114,9 @@ pub struct AgentTurnRequest {
     pub visible_tool_names: Option<HashSet<String>>,
 
     /// Per-turn synthesised tools to splice alongside `tools_registry`.
-    /// The dispatch path uses this to carry `ArchetypeDelegationTool` /
-    /// `SkillDelegationTool` instances built fresh each turn from the
-    /// active agent's `subagents` field and the current Composio
+    /// The dispatch path uses this to carry `ArchetypeDelegationTool`
+    /// instances and deferred Composio action tools built fresh each turn
+    /// from the active agent's `subagents` field and the current Composio
     /// integrations — tools that don't exist in the global startup
     /// registry because they depend on per-user runtime state.
     /// Empty vec for agents that don't delegate.

crates/openhuman-core/src/agent/debug/mod.rs

@@ -449,8 +449,8 @@ async fn render_integrations_agent(config: &Config, toolkit: &str) -> Result<Dum
     let prompt_tools: Vec<PromptTool<'_>> = rendered_tools
         .iter()
         .map(|t| PromptTool {
-            name: t.name(),
-            description: t.description(),
+            name: std::borrow::Cow::Borrowed(t.name()),
+            description: std::borrow::Cow::Borrowed(t.description()),
             parameters_schema: Some(t.parameters_schema().to_string()),
         })
         .collect();

crates/openhuman-core/src/agent/harness/definition/agent_definition.rs

@@ -208,18 +208,16 @@ pub struct AgentDefinition {
     ///   agent's `delegate_name` override) and whose description is the
     ///   target agent's [`AgentDefinition::when_to_use`].
     ///
-    /// * [`SubagentEntry::Skills`] — a single collapsed
-    ///   [`SkillDelegationTool`] named `delegate_to_integrations_agent`
-    ///   that takes the toolkit slug as an argument and routes to the
-    ///   generic `integrations_agent` with the corresponding
-    ///   `skill_filter` pre-populated (#1335).
+    /// * [`SubagentEntry::Skills`] — no delegation tool. The connected
+    ///   Composio toolkits' actions join this agent's `Deferred` catalogue
+    ///   (reached through `tool_search`, called directly), and the entry
+    ///   admits no sub-agent id: see [`AgentDefinition::allowed_subagent_ids`].
     ///
     /// `subagents` is intentionally separate from [`AgentDefinition::tools`]
     /// so that reading a TOML makes the distinction obvious: `tools` is
     /// "what I execute directly", `subagents` is "what I can delegate to".
     ///
     /// [`ArchetypeDelegationTool`]: crate::agent::orchestration::tools::ArchetypeDelegationTool
-    /// [`SkillDelegationTool`]: crate::agent::orchestration::tools::SkillDelegationTool
     #[serde(default, deserialize_with = "deserialize_subagent_entries")]
     pub subagents: Vec<SubagentEntry>,
 
@@ -275,6 +273,24 @@ pub struct AgentDefinition {
 }
 
 impl AgentDefinition {
+    /// The agent ids this definition may spawn, derived from
+    /// [`AgentDefinition::subagents`]. Only [`SubagentEntry::AgentId`]
+    /// entries admit a target; the `{ skills = "*" }` wildcard used to map to
+    /// `integrations_agent` here, which is what let a chat agent spin up a
+    /// sub-agent for one integration action it can now search for and call
+    /// itself. The runner's spawn gate (`parent.allowed_subagent_ids`) reads
+    /// this, so a definition without a bare id for an agent cannot reach it
+    /// through `spawn_async_subagent` either.
+    pub fn allowed_subagent_ids(&self) -> Vec<String> {
+        self.subagents
+            .iter()
+            .filter_map(|entry| match entry {
+                SubagentEntry::AgentId(id) => Some(id.clone()),
+                SubagentEntry::Skills(_) => None,
+            })
+            .collect()
+    }
+
     /// Display name with fallback to id.
     pub fn display_name(&self) -> &str {
         self.display_name.as_deref().unwrap_or(&self.id)

crates/openhuman-core/src/agent/harness/definition/subagents.rs

@@ -22,11 +22,11 @@ use serde::{Deserialize, Deserializer, Serialize};
 pub enum SubagentEntry {
     /// Delegate to a specific built-in or custom agent by id.
     AgentId(String),
-    /// Expand at build time to a single collapsed
-    /// `delegate_to_integrations_agent` tool whose `toolkit` argument
-    /// selects which connected Composio toolkit to route to, with
-    /// `skill_filter` pre-set on the underlying `integrations_agent`
-    /// dispatch (#1335).
+    /// Expand at build time to the connected Composio toolkits' actions as
+    /// `Deferred` tools — off the wire, found through the harness's
+    /// `tool_search`, and called directly by this agent. No sub-agent is
+    /// reachable through this entry: it widens the searchable catalogue,
+    /// not the spawnable set.
     Skills(SkillsWildcard),
 }
 

crates/openhuman-core/src/agent/harness/definition/tier.rs

@@ -79,10 +79,9 @@ impl std::fmt::Display for AgentTier {
 /// pairs at boot (see
 /// [`crate::agent::registry::agents::validate_tier_hierarchy`]). The
 /// runtime spawn gate (`run_subagent`) reuses it as defense-in-depth, but
-/// deliberately exempts worker *parents* — at runtime a worker only reaches the
-/// spawn chokepoint via the documented collapsed `delegate_to_integrations_agent`
-/// path (→ `integrations_agent`, itself a worker), which the loader intentionally
-/// leaves untouched.
+/// deliberately exempts worker *parents* — a worker's `subagents` list holds
+/// no agent id (the loader rejects one), so the only runtime spawn a worker
+/// reaches is one the host dispatched for it, not one it chose.
 pub fn validate_tier_transition(parent: AgentTier, child: AgentTier) -> Result<(), String> {
     match (parent, child) {
         (AgentTier::Worker, _) => Err(format!(

crates/openhuman-core/src/agent/orchestration/README.md

@@ -124,9 +124,11 @@ name:
 - Control: `steer_subagent`, `continue_subagent`, `close_subagent`,
   `wait_subagent`, `wait`, `wait_loop`, `list_subagents`.
 - Delegation: `DelegateGraphTool` (`delegate_graph.rs`),
-  `ArchetypeDelegationTool` and `SkillDelegationTool` (names set per
-  instance, e.g. `delegate_to_integrations_agent`), `CollapsedDelegationTool`
-  (`delegate_to`), and `agent_prepare_context`.
+  `ArchetypeDelegationTool` (name set per instance, e.g. `research`),
+  `CollapsedDelegationTool` (`delegate_to`), and `agent_prepare_context`.
+  There is no integrations delegate: connected Composio actions are
+  `Deferred` tools on the orchestrator's own belt, found through
+  `tool_search` and called directly (`tools/orchestrator_tools.rs`).
 
 `dispatch.rs` (`dispatch_subagent`, the shared spawn path every tool above
 calls), `awaiting_user.rs` (the awaiting-user envelope), and

crates/openhuman-core/src/agent/orchestration/tools.rs

@@ -8,8 +8,7 @@
 //! - **Control**: `steer_subagent`, `continue_subagent`, `close_subagent`,
 //!   `wait_subagent`, `wait` / `wait_loop`, `list_subagents`.
 //! - **Delegation**: `DelegateGraphTool`, `ArchetypeDelegationTool`,
-//!   `SkillDelegationTool`, `CollapsedDelegationTool` (`delegate_to`), and
-//!   `agent_prepare_context`.
+//!   `CollapsedDelegationTool` (`delegate_to`), and `agent_prepare_context`.
 //!
 //! `dispatch.rs`, `awaiting_user.rs`, and `worker_thread.rs` are `pub(crate)`
 //! helpers shared by the tools above (the common spawn path, the awaiting-user
@@ -39,8 +38,6 @@ mod delegate_graph;
 mod dispatch;
 #[path = "tools/list_subagents.rs"]
 mod list_subagents;
-#[path = "tools/skill_delegation.rs"]
-mod skill_delegation;
 #[path = "tools/spawn_async_subagent.rs"]
 mod spawn_async_subagent;
 #[path = "tools/spawn_parallel_agents.rs"]
@@ -94,7 +91,6 @@ pub(crate) use delegate_graph::DelegateGraphDispatch;
 pub use delegate_graph::DelegateGraphTool;
 pub(crate) use list_subagents::ListSubagentsDispatch;
 pub use list_subagents::ListSubagentsTool;
-pub use skill_delegation::{SkillDelegationTool, INTEGRATIONS_DELEGATE_TOOL_NAME};
 pub(crate) use spawn_async_subagent::SpawnAsyncSubagentDispatch;
 pub use spawn_async_subagent::{scope_spawn_async_subagent_spec, SpawnAsyncSubagentTool};
 pub(crate) use spawn_parallel_agents::SpawnParallelAgentsDispatch;

crates/openhuman-core/src/agent/orchestration/tools/agent_prepare_context_tests.rs

@@ -36,14 +36,14 @@ fn build_scout_prompt_includes_request_focus_and_catalog() {
     let prompt = AgentPrepareContextTool::build_scout_prompt(
         "summarise my unread gmail",
         Some("last 24h"),
-        "- delegate_to_integrations_agent: route to a connected integration\n",
+        "- research: web and docs crawler\n",
     );
     assert!(prompt.contains("[Request]"));
     assert!(prompt.contains("summarise my unread gmail"));
     assert!(prompt.contains("[Focus]"));
     assert!(prompt.contains("last 24h"));
     assert!(prompt.contains("[Orchestrator tools]"));
-    assert!(prompt.contains("delegate_to_integrations_agent"));
+    assert!(prompt.contains("research"));
     assert!(prompt.contains("[context_bundle]"));
 }
 
@@ -398,16 +398,13 @@ async fn catalog_lists_the_parents_synthesised_delegates_from_its_visible_specs(
         ],
         vec![
             catalog_spec("echo", "durable"),
-            catalog_spec(
-                "delegate_to_integrations_agent",
-                "route to a connected integration",
-            ),
+            catalog_spec("research", "web and docs crawler"),
             catalog_spec("agent_prepare_context", "this tool"),
         ],
     );
     let catalog = AgentPrepareContextTool::render_parent_tool_catalog(Some(&ctx));
     assert!(
-        catalog.contains("- delegate_to_integrations_agent: route to a connected integration\n"),
+        catalog.contains("- research: web and docs crawler\n"),
         "the parent's delegate must be recommendable: {catalog:?}"
     );
     assert!(catalog.contains("- echo: durable\n"));

crates/openhuman-core/src/agent/orchestration/tools/collapsed_delegation.rs

@@ -15,12 +15,10 @@
 //! enum, with each target's `when_to_use` kept verbatim in the description —
 //! the routing information survives in full, the repetition does not.
 //!
-//! This is the same collapse [`SkillDelegationTool`] already applied to the
-//! *other* delegation axis (#1335): one `delegate_to_integrations_agent` with
-//! a `toolkit` argument, instead of one `delegate_<toolkit>` per connected
-//! Composio integration. That change made the schema constant in the
-//! integration dimension; this one makes it constant in the sub-agent
-//! dimension. The two are now consistent.
+//! The integration axis went a step further: connected Composio actions are
+//! `Deferred` tools reached through `tool_search` and called directly, so
+//! that axis has no delegation tool at all (`orchestrator_tools`). This one
+//! makes the sub-agent axis constant in the sub-agent dimension.
 //!
 //! # Why collapse rather than pack
 //!
@@ -52,12 +50,9 @@
 //! builder's collision guard resolves a clash by dropping the *synthesised*
 //! tool. Naming this one `delegate` would therefore have removed the
 //! orchestrator's entire delegation surface for exactly those users, silently.
-//! It also puts this tool in the same family as its sibling
-//! `delegate_to_integrations_agent`.
 //!
 //! [`DelegateTool`]: crate::agent::tools::DelegateTool
 //! [`ArchetypeDelegationTool`]: super::ArchetypeDelegationTool
-//! [`SkillDelegationTool`]: super::SkillDelegationTool
 //! [`ToolExposure::Hidden`]: tinytools::ToolExposure::Hidden
 
 use async_trait::async_trait;
@@ -102,11 +97,7 @@ impl CollapsedDelegationTool {
     /// Build the collapsed tool, or `None` when there is nothing to route to.
     ///
     /// `None` rather than an empty enum: a `delegate` tool whose `agent` has no
-    /// valid value is a schema the model can only call wrongly, and the
-    /// sibling [`SkillDelegationTool::for_connected`] already returns `None` on
-    /// an empty toolkit list for the same reason.
-    ///
-    /// [`SkillDelegationTool::for_connected`]: super::SkillDelegationTool::for_connected
+    /// valid value is a schema the model can only call wrongly.
     pub fn for_targets(targets: Vec<DelegateTarget>) -> Option<Self> {
         if targets.is_empty() {
             return None;

crates/openhuman-core/src/agent/orchestration/tools/collapsed_delegation_tests.rs

@@ -31,7 +31,7 @@ fn tool() -> CollapsedDelegationTool {
 #[test]
 fn an_empty_target_list_produces_no_tool() {
     // An `agent` enum with no valid value is a schema the model can only call
-    // wrongly. Mirrors `SkillDelegationTool::for_connected`.
+    // wrongly.
     assert!(CollapsedDelegationTool::for_targets(Vec::new()).is_none());
 }