Profile Seeding

Profiles start empty. When a user authenticates for the first time, their profile contains a phone number and nothing else. Your agent will greet them generically — "Hello! How can I help you?" — because it has nothing to work with.

Seeding fills the profile with real data before the first conversation. The richer the seed, the more personal the first interaction. Connect Gmail and your agent knows the user's name, occupation, interests, and recent activity within 10 seconds. Import chat history and your agent inherits context from the user's other AI conversations.

Without seeding, profiles build organically from conversations over days or weeks. With seeding, your agent recognizes users from the very first message.

The difference

What your LLM sees in the system prompt — before and after seeding.

Before seeding — profile.format() returns:

User:
Phone: ...1234

The LLM has nothing to personalize with. It says "Hello! How can I help you?"

After connecting Gmail (~10 seconds) — profile.format() returns:

User:
Name: Christian Ancheta
Email: christian@example.com
Occupation: Software Engineer
Location: Orlando, FL
Interests: AI infrastructure, prediction markets

Connected: gmail

About this user:
Building Configure — the identity layer for AI agents. Recently coordinating
on prediction market integration. Interested in Japan travel this summer.

CONFIGURE GUIDELINES — handling personal data responsibly
...

The LLM sees a real person. It says "Hey Christian — I see you're working on AI infrastructure in Orlando. How can I help?"

Seeding patterns

1. Tool Connect

The richest source. User connects Gmail, Calendar, Drive, or Notion. Configure syncs and analyzes their data automatically.

Frontend (recommended):

<configure-connection-list
  api-key="pk_..."
  auth-token="TOKEN"
  user-id="USER_ID"
  agent="my-agent"
  tools="gmail,calendar,drive,notion"
></configure-connection-list>

Listen for connections:

document.addEventListener('configure:tool-connect', (e) => {
  console.log(`Connected: ${e.detail.tool}`);
});

Server-side alternative:

const { url } = await client.tools.connect(token, 'gmail');
// Redirect user to `url` for OAuth
// After OAuth completes:
await client.tools.sync(token, 'gmail');

What each tool produces:

Tool	Data	Time
Gmail	Identity synthesis (name, occupation, interests), ranked emails, key contacts	~10 seconds
Calendar	Upcoming events, schedule patterns	~10 seconds
Drive	Searchable files, document context	~15 seconds
Notion	Searchable pages, workspace content	~15 seconds

Gmail is the richest source by far. If the developer adds one seeding mechanism, it should be this.

2. Memory Import

User-driven. User exports their chat history from ChatGPT, Claude, or Gemini and pastes it into the import component. Configure extracts memories from the imported content.

<configure-memory-import
  api-key="pk_..."
  auth-token="TOKEN"
  user-id="USER_ID"
  agent="my-agent"
  providers="chatgpt,claude,gemini"
></configure-memory-import>

document.addEventListener('configure:import-complete', (e) => {
  console.log(`Imported from: ${e.detail.provider}`);
});

This makes profiles interoperable. What the user told ChatGPT about their preferences, your agent now knows. Time: ~30 seconds (user action + extraction).

3. Conversation Ingest

Programmatic. Send past conversations and Configure extracts memories.

// Fire-and-forget — returns immediately
await client.profile.ingest(token, userId, [
  { role: 'user', content: 'I prefer window seats and fly United' },
  { role: 'assistant', content: 'Noted! I\'ll keep that in mind for flight searches.' },
]);

// With memory criteria — focus extraction on specific topics
await client.profile.ingest(token, userId, messages, {
  memoryCriteria: 'dietary preferences, travel style, budget range',
});

// Synchronous — blocks until extraction completes
await client.profile.ingest(token, userId, messages, { sync: true });

Use this for migration (importing conversations from another system) or for seeding from the current session's messages.

4. Batch Seed

Developer has existing user data. Import profiles from a CRM, database, or another system — up to 50 users at once.

// Batch mode — multiple users
await client.profile.ingest([
  {
    userId: 'user-1',
    messages: [{ role: 'user', content: 'I work in finance, based in NYC. Vegetarian.' }],
  },
  {
    userId: 'user-2',
    messages: [{ role: 'user', content: 'Software engineer in Austin. Loves hiking.' }],
  },
]);

// Text mode — freeform text for a single user
await client.profile.ingest(token, userId, {
  text: 'Senior designer at Stripe. Prefers dark mode. Frequent traveler, pescatarian.',
});

The migration pattern. Bring existing user knowledge into Configure so profiles are rich from day one.

5. Manual Remember

Precise and instant. Save a single fact about the user.

await client.profile.remember(token, userId, 'Prefers dark mode');
await client.profile.remember(token, userId, 'Allergic to shellfish');
await client.profile.remember(token, userId, 'Working on a startup in AI infrastructure');

Facts appear in the profile immediately. Use for precision. Not for bulk seeding.

Choosing a pattern

Scenario	Best approach	Why
Frontend with auth UI	Tool Connect + Memory Import	Richest data, user-driven
Migrating from another system	Batch Seed	Bring existing knowledge
Backend-only, no frontend	Conversation Ingest or Manual	No UI needed
MVP, ship fast	Organic (just use ingest() after each turn)	Already in the quick-start, zero extra code
Enterprise with CRM data	Batch Seed + Tool Connect	Migrate first, then enrich

Try it

1. Start your app and authenticate with your phone number
2. Connect Gmail (or import chat history)
3. Wait 10-30 seconds for the data to process
4. Send a message: "What do you know about me?"

Your agent should respond with specific details — your name, what you do, what you've been working on — drawn entirely from your connected data. Not "Hello! How can I help you today?" Something that proves it knows who you are.

That's what your users will experience. The first impression is no longer generic.

Troubleshooting

If the greeting is still generic after seeding, call profile.get() directly and check the response. If identity fields are empty, the sync may not have completed — wait a few more seconds and try again. If profile.format() returns data but the agent ignores it, verify the formatted string is actually in the system prompt.

Next steps

• Connected Tools — Detailed guide on tool connections, OAuth flow, and search operations
• Profiles & Memory — Deep dive on memory extraction, batch ingestion, and profile structure
• Atlas Reference Agent — Complete working agent demonstrating all seeding patterns