Getting Started

Create Your First Mesh

Welcome! In a few minutes you’ll have a Mesh that can process a structured request and respond intelligently. We’ll start with a simple “analyze an issue” example and layer in concepts as you go.

You’ll go through these phases:

1. Prep (sign in / gather a model key)
2. Model Provider
3. Model Set
4. Pick your path (AI Creator or Manual)
5. Agent (manual path only)
6. Mesh
7. Invoke & iterate
8. Optional enhancements (grounding, tools)

Relax, we’ll walk through each step.

0. Prep

Sign in at https://app.partite.ai with a Google or GitHub account. You will use the hosted cloud UI for all steps in this guide. Self-hosted modes exist, but they add infrastructure work - skip them until you need full data residency.

Have at least one foundation model API key ready (OpenAI, Anthropic, or Google). That’s all you need for now.

1. Add a Model Provider and Profiles

In the UI, create a Model Provider (e.g. “OpenAI” or “Anthropic”). Paste credentials / keys.

Tip: Name providers clearly, especially if you’ll mix vendors.

Next, you might want to add a Model Profile or two. A Model Profile is a specific model + its tuning (temperature, reasoning mode, etc.).

Create one or two profiles:

• A cheaper / faster one (for simple support or routing tasks).
• A more capable one (for heavier reasoning).

You can also just use the pre-configured profiles created by the system when you added your model provider.

2. Create Your First Model Set

Now create a Model Set:

• Choose a default profile.
• Add a rule or two (e.g. “if agent complexity >= medium use advanced_model”). Rules match on tags + complexity so you don’t hardcode model choices inside prompts.

At this point you understand providers and cost/right-sizing. Perfect moment to choose your build path.

3. Pick Your Path

You now have the foundation pieces (Provider + Model Set). Decide how you want to assemble the rest:

Path A: AI-Powered Creator (fast prototype)

• Open the Mesh creation page with auto-create.
• Describe your goal (“Analyze bug reports and summarize likely root cause”).
• It generates Agents, a Mesh, and wiring.
• Skip directly to Step 5 (Invoke) and refine later.

Path B: Manual (more control)

• Continue below to handcraft an Agent and Mesh.
• Recommended if you want to learn the concepts deeply.

If you tried Path A and want to learn internals, you can still read on - everything is editable.

4 (Manual Path). Create Your First Agent

Think of an Agent as a focused specialist. Keep scope tight.

Configure:

• Identity: Optional persona (“You are a calm diagnostics assistant”).
• Task Instructions: Clear, outcome-focused (“Diagnose the reported issue. Ask for missing reproduction steps only if essential.”).
• Input Message Schema: Start small. Example:

  {
    "type": "object",
    "properties": {
      "issueText": { "type": "string", "description": "Raw user report text" },
      "environment": { "type": "string", "description": "Runtime or OS if known" }
    },
    "required": ["issueText"]
  }
  Every field needs a description - this really helps output accuracy.
• Memory Slots (optional): Add one if you’ll retain context across turns (“recent_diagnostics”).
• MCP Tools (optional now): Skip unless you have a tool (logs, repo search, etc.).
• User Interaction Flags: Enable asking questions only if you expect back‑and‑forth.

Each edit versions the Agent automatically. Use complexity + tags to influence Model Set rules later.

5. Assemble a Mesh

Create a Mesh:

1. Associate the Model Set you built earlier (so rules apply).
2. Add an Intent (entry point):
   • Pick the Agent Version you just created.
   • Define one or more Output Message Types the Agent can emit. Example:

     {
       "type": "object",
       "properties": {
         "summary": { "type": "string", "description": "High level explanation" },
         "probableCause": { "type": "string", "description": "Most likely root cause" },
         "nextStep": { "type": "string", "description": "Recommended action" }
       },
       "required": ["summary"]
     }
3. (Optional) Add Call Links later as you decompose tasks (“LogSearcher” agent, “FixGenerator” agent).
4. (Optional) Add Transfer Links for router patterns (“Classifier” passes control to “Security” vs “Performance” agent).

Labeling: Edits modify the draft. When happy, apply a label like “prod”. Future updates happen on the draft until you label again (“staging”, test, then re-label to “prod”).

6. Invoke the Mesh (Conversation API)

You’re ready to talk to it. Two styles:

Streaming (see thoughts, progress, tasks live):

curl -X POST https://api.partite.ai/conversations/new \
  -H "Authorization: Bearer <API_KEY_ID>:<API_KEY_SECRET>" \
  -H "Content-Type: application/json" \
  -d '{
    "meshLabel": "prod",
    "intent": "AnalyzeIssue",
    "input": {
      "issueText": "App crashes when saving after upgrade to v2.3",
      "environment": "macOS 14"
    }
  }'

# Stream events (thinking, messages, tasks, response):
curl -N -H "Authorization: Bearer <API_KEY_ID>:<API_KEY_SECRET>" \
  https://api.partite.ai/conversations/<conversation_id>/requests/<request_id>/events

Non‑streaming (simpler blocking fetch):

# After creating the conversation (same POST as above):
curl -H "Authorization: Bearer <API_KEY_ID>:<API_KEY_SECRET>" \
  https://api.partite.ai/conversations/<conversation_id>/requests/<request_id>/response

Event types you may see: thinking, message, task, task_response, response, error, cancelled. response / error / cancelled are terminal.

7. Iterate Productively

Healthy loop:

1. Review responses (and trace data if available).
2. Tighten instructions (remove fluff; clarify edge cases).
3. Evolve schema (add a field only when repeatedly missing data).
4. Split responsibilities (new Agent + Call Link) if output feels unfocused.
5. Adjust Model Set rules (promote complex agents to stronger models).
6. Label draft → test → promote.

Rollback = re-target a previous label or Agent Version. No guesswork.

8. Optional: Grounding Early

If certain fields must be factually sourced (IDs, metrics, brief facts), add x-partite-grounding-config to those schema properties. This enforces citations without stuffing raw data into prompts. Start small; enable on the highest risk fields.

9. Add Tools (When Ready)

MCP Connections let agents:

• Fetch logs
• Search code
• Pull metrics
• Generate artifacts (reports, patches)

Associate only the tools relevant to the Agent’s purpose. Fewer tools = clearer reasoning.

10. Common Early Pitfalls (And Fixes)

11. Troubleshooting Quick Checks

• Getting empty outputs? Verify required schema fields are present in request.
• Strange model choice? Inspect Model Set rule order.
• Overlong responses? Tighten Output Message Type descriptions.
• Not seeing progress events? Confirm user interaction flags (thinking/messages) enabled.

12. Next Steps

When the basics feel solid:

• Add a second Agent for code fixes.
• Introduce a router agent via Transfer Links.
• Enable grounding on “probableCause”.
• Attach artifacts (logs, screenshots) to conversations.
• Export config to Terraform for review / promotion workflow.
• Add a webhook to trigger analysis automatically on new issue events.

You now have the full lifecycle: Configure -> Label -> Invoke -> Observe -> Refine -> Expand.

Enjoy building; your mesh will grow naturally as you slice responsibilities into focused agents. Reach out if you hit friction.