Skip to main content

Composing AI Teams

MeetLoyd lets you assemble custom AI teams by combining agents, skills, and avatars from different sources — the Store, your own creations, or third-party integrations. Think of it as building your dream team from the best available components, without starting from scratch.

This guide walks through team composition end to end: creating manifests, mixing components, locking versions for production, and deploying with confidence.

Overview​

MeetLoyd's composable architecture lets you:

  • Mix and match agents from the Store with your custom agents
  • Override skills to swap in your preferred integrations
  • Configure avatars for video and voice representation
  • Version lock components for production stability
  • Customize behavior without forking components

Creating Your First Custom Team​

Step 1: Start with a Manifest​

Create a team manifest file that declares your team name, slug, version, and the components it includes (agents, skills, avatars). You also define an orchestration mode and entry agent.

info

Manifests use YAML or JSON format. The deployer accepts both meetloyd-team (single team) and meetloyd-app (full app) formats.

Step 2: Add Agents​

Add agents from different sources using reference prefixes:

Reference PrefixSourceExample
store://Components from the MeetLoyd Storestore://agents/sdr-agent
local://Your custom-built componentslocal://agents/my-coordinator
catalog://Platform catalog templatescatalog://sales-team
preset://Legacy preset referencespreset://support

Each agent entry includes a reference, an optional version constraint, and a local ID used for routing within the team.

Step 3: Add Skills​

Skills give agents capabilities. Declare shared skills at the team level so multiple agents can use the same integration (for example, a CRM skill shared by your SDR and support agents).

Step 4: Configure Avatars (Optional)​

Add video or voice avatars by referencing MeetLoyd's avatar service. Each avatar can be assigned to a specific agent via its local ID.

Step 5: Define Orchestration​

Configure how agents work together:

SettingDescription
modehierarchical (manager routes to specialists), parallel (agents work simultaneously), sequential (agents execute in order), round_robin (requests distributed evenly), or smart_routing (LLM-scored dynamic routing)
entryAgentIdThe local ID of the agent that receives incoming requests first
intentRoutingRules mapping user intents to specific agents
fallbackAgentIdAgent that handles unmatched intents
escalationConditions that trigger automatic escalation (deal size, sentiment, etc.)

Step 6: Deploy​

Deploy your manifest from the dashboard or use the deployment pipeline. The deployer validates the manifest, resolves component versions, provisions OpenFGA authorization tuples, assigns SPIFFE identities, and creates the team in stopped status.

warning

Teams are created in stopped status after deployment. Start them through the Team Starting Wizard in the dashboard — never set the status to running directly.

Mixing Store and Custom Components​

You do not have to build everything from scratch. Start with proven Store components and add your custom pieces where you need domain-specific expertise.

Overriding Store Agent Skills​

Store agents come with default skills. You can override them with your preferred alternatives using a skillOverrides field. For example, swap out a default Salesforce CRM skill for your HubSpot integration, or add a LinkedIn prospecting skill on top of the defaults.

Customizing Agent Behavior​

Adjust an agent's behavior without forking:

CustomizationWhat It Controls
contextPromptTemplateInject company-specific context (name, product, industry)
memoryConfigMax context tokens and summary thresholds
responseStyleMax response length and tone

Sharing Skills Across Agents​

Define a skill once at the team level and specify which agents share it via a sharedBy list. This avoids duplicating skill configurations across agents.

Version Locking Strategies​

Version management is critical for production stability. Use different strategies depending on your environment:

StrategyVersion SyntaxBest ForTrade-off
Flexible^1.0.0 (any 1.x.x)DevelopmentAlways get latest features; behavior may change
Moderate~1.2.0 (only 1.2.x patches)StagingGet bug fixes; no feature surprises
Strict1.2.3 with locked: trueProductionComplete predictability; manual updates required
tip

Use flexible versions in development, moderate in staging, and strict in production. This gives you fast iteration where it matters and stability where it counts.

Lock Files​

When you deploy, MeetLoyd generates a lock file with exact resolved versions, timestamps, and checksums. Best practices:

  • Commit lock files to version control
  • Review lock file changes in pull requests
  • Use lock files as rollback references

Checking for Updates and Upgrading​

From the dashboard, you can check all components for available updates. Updates are categorized as major, minor, or patch. You can upgrade individual components or batch-upgrade all patch updates.

Rolling Back​

If an update causes issues, redeploy from a known-good lock file or roll back a specific component to a previous version.

Using Model Aliases​

Instead of tracking specific model version strings, use -latest aliases that resolve automatically at deploy time:

AliasResolves To
claude-sonnet-latestLatest Claude Sonnet
gemini-flash-latestLatest Gemini Flash
gpt-latestLatest GPT
qwen-coder-latestLatest Qwen Coder

This makes manifests portable. When models change, update the alias map centrally instead of editing every manifest.

Securing Agents with Authorization​

Declare what resources each agent can access directly in your manifest. Specify resource types (CRM objects, email domains, git repos) and the relation (reader, editor, sender, etc.). Permissions are provisioned as OpenFGA tuples at deploy time, enforcing least-privilege from day one.

See the Agent Authorization guide for full details.

Adding Agent Identity​

For agents that need to authenticate to external services, declare SPIFFE identity configuration in your manifest. Specify target audiences and SVID time-to-live. The agent receives a SPIFFE ID automatically at deploy time and can request JWT-SVIDs scoped to the declared audiences.

See the Agent Identity documentation for full details.

Development Workflow with Hot-Reload​

When developing catalog manifests locally:

  1. Start the dev server
  2. Edit any YAML file in the catalog directory
  3. The catalog cache invalidates automatically (300ms debounce)
  4. Your next request uses the updated manifest

No restart needed. Hot-reload is automatic in development and disabled in production.

Real-World Examples​

E-commerce Support Team​

A triage agent from the Store handles initial routing. A returns specialist (also from the Store) handles refund requests. A custom order-tracker agent connects to your warehouse API. Skills include Shopify, Zendesk, and your internal warehouse integration. Orchestration routes return requests to the specialist and order inquiries to the tracker, with the triage agent as fallback.

Enterprise Sales Team​

A locked-version enterprise SDR with LinkedIn Sales Navigator skill override. A locked-version account executive. A demo specialist customized with industry-specific context. Shared skills include Salesforce CRM (locked), Gong call analysis, and DocuSign. Escalation rules trigger when deal size exceeds $100K or sentiment drops below 0.3.

Parallel Research Team​

A web researcher and data analyst run in parallel. Their outputs merge and flow to a report writer that synthesizes the final deliverable.

Best Practices​

  1. Start with Store components — do not reinvent the wheel
  2. Customize, don't fork — use customizations and skill overrides
  3. Lock production versions — use exact versions with locked: true
  4. Test in staging first — always deploy to staging before production
  5. Commit lock files — track exact versions in version control
  6. Monitor updates — regularly check for security patches
  7. Document customizations — use comment fields liberally
  8. Use semantic versioning — for your own manifest versions

Next Steps​