Overview

If you've built outbound workflows in Clay, you know the pattern: enrich leads, score them with formulas, generate content with prompts, push to your sequencer. It works—until your positioning changes, a new product launches, or someone asks why a lead scored the way it did.

This guide covers how to use Octave as the context layer for your Clay workflows. Instead of embedding your GTM knowledge in prompt chains that you'll need to rewrite next quarter, you'll maintain it in one place and call it at runtime.

What we'll cover:

• What Clay and Octave each do, and how they complement each other
• Why separating context from execution matters
• How Octave's Library, Playbooks, and Agents work
• Setting up the Octave + Clay integration step by step
• Runtime context with concrete examples
• A worked example: qualifying leads before generating sequences

What is Clay?

Clay is an execution engine for GTM Engineers—unmatched at aggregating data, chaining enrichments, and triggering downstream actions. It provides a spreadsheet-like interface where you can build multi-step workflows, pull from enrichment providers, and push output to your sales and marketing tools.

Core Clay Capabilities

• Data Enrichment: Aggregate data from multiple enrichment providers into unified lead and account records
• Workflow Automation: Build multi-step workflows using formulas, conditionals, and API integrations
• AI Integrations: Connect to LLMs and AI services for content generation and classification
• CRM & Sequencer Sync: Push enriched data and generated content to CRMs and sequencers like Salesforce, HubSpot, Outreach, Salesloft, Instantly, and Smartlead

Clay excels at execution—aggregating signals, chaining enrichments, and orchestrating data flow. But execution needs context, and that context ends up embedded directly in Clay: scoring logic in formulas, ICP definitions in conditionals, messaging assumptions spread across prompt chains. Every time your ICP shifts, a new product launches, or positioning changes, you're rewriting prompts and debugging fragile workflows.

What is Octave?

Octave is a GTM context engine—infrastructure that makes your go-to-market motion as programmable and maintainable as a software codebase. It provides a structured, versioned, API-accessible model of your GTM knowledge that downstream tools like Clay can consume at runtime.

Think of Octave as the "GTM repo" your team has been missing. Instead of tribal knowledge scattered across Notion pages, Slack threads, and prompt chains, Octave centralizes your positioning, ICPs, personas, value props, and competitive intelligence into a living, queryable knowledge graph.

Three core concepts:

The Library

The Library is Octave's central source of truth—a structured repository of everything your GTM team needs to communicate your product's value. It contains:

The Library is designed to be refined over time. Business users can update it using natural language, while engineers access the same data via API. Every downstream workflow—agents, playbooks, and integrations—consumes from this single source of truth.

Playbooks

Your Library defines what you sell and who you sell to. Playbooks are how you test different ways to frame it.

Playbooks combine Library elements into testable messaging strategies. They bring together offerings, personas, use cases, and strategic angles into coherent GTM motions you can launch, compare, refine, or abandon.

When creating a Playbook, you:

1. Select an offering from your Library
2. Choose a playbook type (sector, function, solution, milestone, competitive, or account-based)
3. Define the core insight or angle of attack
4. Select 1–3 relevant personas and use cases

Octave generates persona-specific value prop hypotheses, strategic messaging, and qualification logic for each playbook. You can refine messaging as you learn what resonates, and changes propagate instantly across all agents using that Playbook.

Playbooks are meant to be living experiments: you evolve them or abandon them based on what works in market. Playbooks feed into agents as strategic positioning context, shaping how messages get generated based on the type, personas, and use cases you've defined.

Agents

Agents are the execution layer—they consume Library and Playbook context to perform specific tasks at runtime. Each agent type does something different:

Agents can auto-select the best Playbook based on lead data, or you can specify one. You configure agents in Octave, test them in the playground, then call them from Clay via API.

Why Use Octave with Clay?

The Problem: Context Embedded in Execution

When you build outbound workflows in Clay without a context layer, your GTM knowledge ends up embedded directly in the table:

• Scoring logic in formulas: ICP definitions become complex conditionals that are hard to understand or modify
• Messaging in prompt chains: Positioning, value props, and competitive context get copy-pasted into HTTP requests
• Tribal knowledge in column names: The "why" behind each enrichment step lives in someone's head

The result is what GTM Engineers sometimes call the "prompt swamp"—a fragile system where:

• Every ICP shift requires rewriting prompts across multiple tables
• New products or personas mean duplicating and modifying entire workflows
• No one knows what the last person tried or why
• Most engineering time goes to maintenance instead of building

The Solution: Separation of Context and Execution

Octave provides the context infrastructure that Clay has been missing. Instead of embedding your GTM knowledge in tables, you codify it once in Octave and consume it everywhere.

This separation delivers concrete benefits:

What You Can Build

Common patterns when combining Octave with Clay:

Prerequisites

Before connecting Octave to Clay, you'll need the following set up in Octave:

What You Need in Clay

• A Clay workspace with access to enrichment features
• A lead table with the data fields required by your agent (varies by agent type)
• Downstream integrations configured for wherever you want to push output (CRM, sequencer, etc.)

Integration Setup

Once you've created and configured your agents in Octave, connecting them to Clay gives you full programmatic access to run agents at scale across your lead lists.

Step 1: Connect Your Octave Account to Clay

You only need to wire the account once. After that, all Octave enrichment types in Clay will use it.

From now on, you can pick any Octave enrichment type in Clay and your agents will be available in the dropdowns.

Step 2: Select and Configure Your Agent

Step 3: Map Data Fields

Select your agent in the dropdown, then map Clay columns to the required inputs:

Step 4: Add Runtime Context

Runtime context passes lead-specific data that varies per row. This is where you provide information that the agent can't get from web research—data you've already enriched in Clay or signals specific to that lead.

When to Use Runtime Context

• You have enrichment data (employee count, tech stack, funding stage) that helps qualification accuracy
• You have intent signals (website visits, event attendance, content downloads) that should influence messaging
• You want to pass specific instructions for certain leads

Concrete Examples

How to Configure

In the Octave enrichment configuration, you'll see fields for runtime context. Link your Clay columns to these fields. You can also add runtime instructions—specific directions for how the agent should use the context.

Step 5: Test and Run

Worked Example: Qualify then Sequence Chain

This example builds a workflow that qualifies companies, then generates sequences only for high-fit prospects.

Setup in Octave

1. Ensure your Library has at least one Offering with qualifying questions defined
2. Create a Playbook for your outbound motion
3. Build a Qualify agent linked to your Offering
4. Build a Sequence agent linked to your Playbook
5. Test both in the playground

Setup in Clay

Column 1: Qualify Company

1. Add Enrichment → Octave → Qualify
2. Select your Qualify agent
3. Map: Company Domain, Company Name
4. (Optional) Add runtime context: pass employee count from an enrichment column if you have quantitative qualifying questions
5. Run on a test row, inspect the response
6. Add as column: overall_score (or whatever field contains the score)

Column 2: Sequence Agent (Conditional)

1. Add Enrichment → Octave → Sequence
2. Select your Sequence agent
3. Map: Company Name, First Name, Job Title, Company Domain, LinkedIn Profile
4. Set condition: Only run if overall_score >= 7 (scores are out of 10)
5. (Optional) Add runtime context: pass tech stack, recent funding, or website behavior to personalize messaging
6. Run on test rows, verify sequences generate only for qualified leads
7. Add as columns: Email 1, Subject 1, Email 2, Subject 2, etc.

Downstream

Push Email 1, Subject 1, etc. to your sequencer (Outreach, Salesloft, Instantly, etc.) using Clay's native integrations.

Troubleshooting

For persistent issues: test the same inputs in Octave's playground to isolate whether the problem is in Octave or Clay. When contacting support, include your Agent ID and sample request/response.

Best Practices

Library & Playbook Hygiene

• Invest time upfront in your Library. The quality of agent outputs directly correlates with the specificity and accuracy of your Library content. Generic inputs produce generic outputs.
• Keep Personas distinct. Only create a new Persona if you would message them in a meaningfully different way. Over-segmentation dilutes messaging focus.
• Limit Use Cases per Playbook. Select 1–3 use cases to keep the core message focused. Trying to cover everything results in covering nothing well.
• Write qualifying questions carefully. Avoid highly specific quantitative questions (e.g., "Is employee count > 100?") unless you can provide that data as runtime context. The agent will infer answers it can't find, which may be directionally correct but not precise.

Clay Workflow Design

• Chain agents efficiently. Run qualification first, then only run enrichment and content generation on qualified leads. This optimizes both credit usage and processing time.
• Use conditional execution. Set runtime conditions in Clay to control which leads trigger which agents based on scores, firmographics, or prior workflow steps.
• Parse JSON responses properly. Octave returns structured JSON—use Clay's JSON parsing to extract specific fields into separate columns for downstream use.
• Handle edge cases. Build in logic for when agents return warnings or partial data. Not every lead will have complete information.

Runtime Context Strategy

• Don't over-contextualize. Passing too much runtime context can overwhelm the agent. Focus on signals that meaningfully impact qualification or messaging.
• Use runtime instructions sparingly. Runtime instructions can override agent behavior for specific leads, but should be the exception not the rule. If you find yourself needing the same instruction repeatedly, update the agent configuration instead.
• Validate context data quality. Garbage in, garbage out. If your enrichment columns have inconsistent or missing data, the agent will produce inconsistent results.

Iteration & Optimization

• Start narrow, then expand. Begin with one agent type on one segment. Validate quality before scaling to additional agents and segments.
• Use Octave's playground. Agents can be tested in a "playground" environment before being run at scale via API. The metaprompter in Content Agents lets you iteratively improve outputs by providing simple follow-up instructions.
• Close the feedback loop. Track which outputs perform and feed insights back into your Library and Playbook refinement. Playbooks are meant to be living experiments—evolve them based on what works in market.

FAQ