Mets and their tools

Create and adjust Mets, see which tools each one gets, and control which collections it can reach.

A Met is an agent in your workspace: it has a mission, instructions, AI Functions, skills and access to the workspace's data (collections and contacts). With met.agents you create and adjust them from code; with tool introspection you know exactly what each one sees.

Create and adjust Mets

import Met from '@meteor.ia/sdk';

const met = new Met(process.env.MET_API_KEY!, { workspaceId: 40 });

const agent = await met.agents.create({
  name: 'Valeria',
  title: 'Sales advisor',
  mission: 'Qualify and answer inbound leads',
  instructions: 'Be concise. Confirm the budget before booking.',
  model: 'brillante',
});

await met.agents.list();          // every Met in the workspace
await met.agents.retrieve(agent.id);
await met.agents.update(agent.id, { instructions: 'New script.', active: true });

The editable fields are name, title, mission, instructions, model and active (plus disabled_tools, below). To give it a workspace skill: met.agents.linkSkill(agentId, skillId) (and unlinkSkill to take it away).

Pick the level

model is how much capability you give the Met: agil, brillante or genio. If omitted, it uses the platform's default. The response returns it in tier.

await met.agents.update(agent.id, { model: 'agil' });

The change applies from the next execution; Runs already in progress finish on the level they started with. When each level makes sense, and what else makes a Met expensive, is in Architecture: when a flow, when a Met.

See which tools a Met has

This is diagnosis #1 when a Function doesn't surface, or when you don't know what to switch off:

const tools = await met.agents.tools(agent.id);
// [{ name, source: 'collection'|'skill'|'function'|'internal', description, disabled }]

Each tool carries its source (where it comes from) and disabled (whether it is already off for this Met). If your Function doesn't show up with source: 'function', the problem is in the Function itself — no handler, active: false — not in the Met. The names this method returns are the only valid ones for disabled_tools.

Switch tools off per Met

await met.agents.update(agent.id, {
  disabled_tools: ['mcp_meteor_list_items', 'mcp_meteor_get_item'],
});

Disabling a tool does not unlink it: it leaves it out of the set the LLM can call (hidden from the catalog and rejected at runtime). Take the names from agents.tools().

The mcp_meteor_* tools (source internal) are generic: they operate over every collection in the workspace, not over a single one. If you switch off mcp_meteor_list_items, you take it away from the Met for all collections at once. To close off one specific collection, use expose_to_agent (below).

Hide a collection from the Met

So that no path — API, chat or channel — exposes a collection to the LLM, mark it as not visible, without deleting any data:

await met.collections.update(collectionId, { expose_to_agent: false });

expose_to_agent defaults to true. Set it to false for internal data the Met should not consult, and back to true to re-expose it. More in Collections and items.

Which Met answers a run is decided by deterministic routing (the met bind), not by these tools. See Run Mets.

Example: leave a Met with only its Function

const bot = await met.agents.create({ name: 'Quoter', mission: 'Quote over the API' });

// 1. Look at what it has available
const tools = await met.agents.tools(bot.id);

// 2. Switch off everything internal (generic collections) and let only its Function through
const internal = tools.filter((t) => t.source === 'internal').map((t) => t.name);
await met.agents.update(bot.id, { disabled_tools: internal });

// 3. Also close off a sensitive collection on every path
await met.collections.update(internalPricesId, { expose_to_agent: false });

The Met is now scoped to its AI Function, with no indiscriminate access to the workspace's collections.

From technical controls to a Company Brain

Tool assignment and collection visibility let each Met consult only the context its role requires. This role-based governance is one of the foundations of Meteor's operational Company Brain: company knowledge available through WhatsApp and other channels, with permissions defined per agent.