Multi-Agent System

Multi-agent systems involve an orchestrator delegating tasks to specialized agents, which may further delegate to sub-agents. Without governance, delegation chains can escalate privileges, bypass tool restrictions, and lose traceability. This flow shows how TealTiger enforces delegation governance, privilege boundaries, and correlation ID tracing across cooperating agents.

Orchestration Flow

Orchestrator receives task

The orchestrator agent receives a complex task: “Research competitor pricing and update our pricing spreadsheet.” This requires two capabilities — web research and spreadsheet editing — handled by different specialized agents.

TealEngine — Evaluate delegation to Agent A

TealEngine evaluates whether the orchestrator is allowed to delegate the research subtask to Agent A (Research Agent). The engine checks: Does the orchestrator have delegation permission? Is Agent A registered? Is the delegation depth within limits (max depth: 3)?

Agent A delegates to Agent B

Agent A (Research Agent) determines it needs Agent B (Web Scraper) to fetch competitor websites. Agent A attempts to delegate a sub-task to Agent B.

TealEngine — Verify Agent B permissions

TealEngine evaluates the delegation from Agent A to Agent B. It checks: Does Agent A have permission to delegate? Is Agent B registered? Current delegation depth is 2 (Orchestrator → A → B) — within the limit of 3. Critically, Agent B inherits only the permissions of Agent A, not the orchestrator. Privilege cannot escalate through delegation.

Agent B calls tool

Agent B attempts to call the web_scrape tool to fetch competitor pricing pages.

TealRegistry — Tool authorization for Agent B

TealRegistry checks whether web_scrape is allowlisted for Agent B specifically. Each agent has its own tool allowlist — Agent B can use web_scrape and web_search, but cannot use spreadsheet_edit (that’s only allowlisted for the orchestrator).

Agent B returns result

Agent B completes the web scraping and returns competitor pricing data to Agent A, which aggregates the research and returns it to the orchestrator.

TealMemory — Shared memory governance

TealMemory governs the shared memory space. Agent B writes research results to shared memory with classification INTERNAL. The orchestrator can read this data, but Agent B cannot read the orchestrator’s CONFIDENTIAL pricing strategy documents. Memory access is governed by both scope and classification.

TealAudit — Correlation ID traces full chain

TealAudit logs every event in the delegation chain with a shared correlation ID. The audit trail shows: Orchestrator → delegated to Agent A → Agent A delegated to Agent B → Agent B called web_scrape → Agent B returned result → Agent A returned result → Orchestrator updated spreadsheet. A single query on the correlation ID reconstructs the entire chain.

Flow Diagram

Code Example

import {
  TealEngineV12,
  TealRegistry,
  TealMemory,
  TealAudit,
  PolicyMode,
} from 'tealtiger';

// --- Initialize modules ---

const registry = new TealRegistry({
  agents: {
    'orchestrator': {
      canDelegate: true,
      maxDelegationDepth: 3,
      delegateTo: ['research-agent', 'editor-agent'],
      tools: ['spreadsheet_edit', 'send_email'],
    },
    'research-agent': {
      canDelegate: true,
      maxDelegationDepth: 2, // Inherited limit from parent
      delegateTo: ['web-scraper-agent'],
      tools: ['web_search', 'summarize'],
    },
    'web-scraper-agent': {
      canDelegate: false, // Leaf agent, cannot delegate further
      tools: ['web_scrape', 'web_search'],
    },
  },
});

const memory = new TealMemory({
  defaultScope: 'agent-chain',
  classification: {
    enforceReadGovernance: true,
    levels: ['PUBLIC', 'INTERNAL', 'CONFIDENTIAL', 'RESTRICTED'],
  },
  agentAccess: {
    'orchestrator': { maxReadClassification: 'RESTRICTED' },
    'research-agent': { maxReadClassification: 'CONFIDENTIAL' },
    'web-scraper-agent': { maxReadClassification: 'INTERNAL' },
  },
});

const audit = new TealAudit({
  enabled: true,
  redactPII: true,
  outputs: ['file', 'http'],
});

const engine = new TealEngineV12({
  modules: [registry, memory, audit],
  mode: PolicyMode.ENFORCE,
});

// --- Orchestration flow ---

async function handleMultiAgentTask(task: string) {
  // Root context — all child contexts inherit this correlation ID
  const rootContext = engine.createContext({
    agentId: 'orchestrator',
    environment: 'production',
  });

  // Step 1: Orchestrator evaluates delegation to research-agent
  const delegationDecision = await engine.evaluate({
    action: 'delegate',
    fromAgent: 'orchestrator',
    toAgent: 'research-agent',
    task: 'research competitor pricing',
    context: rootContext,
  });

  if (delegationDecision.action === 'DENY') {
    return { blocked: true, reason: delegationDecision.reasonCodes };
  }

  // Step 2: Research agent runs with inherited context
  const researchContext = engine.createChildContext(rootContext, {
    agentId: 'research-agent',
    delegationDepth: 1,
    parentAgent: 'orchestrator',
  });

  // Step 3: Research agent delegates to web-scraper-agent
  const subDelegation = await engine.evaluate({
    action: 'delegate',
    fromAgent: 'research-agent',
    toAgent: 'web-scraper-agent',
    task: 'scrape competitor pricing pages',
    context: researchContext,
  });

  if (subDelegation.action === 'DENY') {
    await audit.log({
      type: 'delegation_denied',
      fromAgent: 'research-agent',
      toAgent: 'web-scraper-agent',
      reason: subDelegation.reasonCodes,
      correlationId: rootContext.correlationId,
    });
    return { blocked: true, reason: subDelegation.reasonCodes };
  }

  // Step 4: Web scraper runs with further restricted context
  const scraperContext = engine.createChildContext(researchContext, {
    agentId: 'web-scraper-agent',
    delegationDepth: 2,
    parentAgent: 'research-agent',
  });

  // Step 5: TealRegistry checks tool authorization for web-scraper-agent
  const toolCheck = await registry.checkTool({
    tool: 'web_scrape',
    agentId: 'web-scraper-agent',
    context: scraperContext,
  });

  if (toolCheck.action === 'DENY') {
    return { blocked: true, reason: ['TOOL_NOT_ALLOWLISTED'] };
  }

  // Step 6: Execute tool
  const scrapedData = await executeTool('web_scrape', {
    urls: ['https://competitor-a.com/pricing', 'https://competitor-b.com/pricing'],
  });

  // Step 7: TealMemory — write results to shared memory
  await memory.store({
    key: `research:${rootContext.correlationId}`,
    value: scrapedData,
    scope: 'agent-chain',
    classification: 'INTERNAL',
    writtenBy: 'web-scraper-agent',
    context: scraperContext,
  });

  // Step 8: Orchestrator reads from shared memory
  const researchResults = await memory.read({
    key: `research:${rootContext.correlationId}`,
    agentId: 'orchestrator',
    context: rootContext,
  });

  // Step 9: Audit the full delegation chain
  await audit.log({
    type: 'multi_agent_task_completed',
    correlationId: rootContext.correlationId,
    delegationChain: ['orchestrator', 'research-agent', 'web-scraper-agent'],
    delegationDepth: 2,
    toolsCalled: ['web_scrape'],
    memoryOperations: { writes: 1, reads: 1 },
  });

  return {
    result: researchResults,
    delegationChain: ['orchestrator', 'research-agent', 'web-scraper-agent'],
    correlationId: rootContext.correlationId,
  };
}

Key Governance Points

Step	Module	Enforcement	What it checks
1	TealEngine	Delegation auth	Orchestrator can delegate to Agent A
2	TealEngine	Depth + privilege	Depth 2/3, privileges inherited (not escalated)
3	TealRegistry	Tool auth	`web_scrape` allowlisted for Agent B
4	Privilege boundary	Isolation	Agent B cannot use orchestrator’s tools
5	TealMemory	Shared memory	Classification-based read/write governance
6	TealAudit	Correlation trace	Single ID traces Orch → A → B → tool → result

Without delegation governance, a low-privilege agent can delegate to a higher-privilege agent and effectively escalate its own permissions. TealEngine enforces that delegated agents inherit the permissions of their parent, never the root orchestrator.

Correlation IDs propagate automatically through createChildContext. Every event in the delegation chain — across all agents — shares the same root correlation ID, making it possible to reconstruct the full chain with a single audit query.

Agentic Patterns

Governance patterns for multi-agent architectures

Execution Identity

How correlation IDs and execution contexts work

TealRegistry API

Agent and tool registration configuration

TealMemory API

Shared memory governance and classification

Getting Started

Core Concepts

Governance Domains

Policy Authoring

Architecture

Integrations

Deployment

API Reference

Cookbook

Compliance & GRC

Guides

Reference

Versions

Playground

Dashboard

Blog

Orchestration Flow

Flow Diagram

Code Example

Key Governance Points

Agentic Patterns

Execution Identity

TealRegistry API

TealMemory API

​Orchestration Flow

​Flow Diagram

​Code Example

​Key Governance Points

​Related Documentation

Agentic Patterns

Execution Identity

TealRegistry API

TealMemory API

Orchestration Flow

Flow Diagram

Code Example

Key Governance Points

Related Documentation