Use the system message

The system message is the first entry in messages, with "role": "system". It sets up the whole conversation: who the assistant works for, what it should and should not do, and any reference material it needs throughout. User messages then carry the individual requests.

{
  "model": "Amara S1.2",
  "messages": [
    { "role": "system", "content": "You are the booking assistant for Tidewater Kayak Tours ..." },
    { "role": "user", "content": "Can I bring my 8-year-old on the sea-cave tour?" }
  ]
}

What belongs where

Keeping stable content in the system message has two benefits. Rules there apply to every turn without repeating them, and the system message is the start of every request, so it is served from the prompt cache once it has been seen. See Pricing.

Use a single system message, at the start

Send one system message as the first item. Later system messages in the middle of a conversation are not a reliable way to change behaviour; to change the rules, rebuild the system message and resend the conversation. If you need to inject information mid-conversation (for example “the customer has now signed in”), add it to the next user message in a clearly marked block.

Structure of a strong system message

A layout that works for most products:

[Role] You are the booking assistant for Tidewater Kayak Tours, a small tour company in Cornwall.
You talk to customers on the website chat.

[Goal] Help customers choose a tour and answer questions about it. Bookings are made on the
website; you cannot book or take payment.

[Rules]
- Answer only from the TOURS and POLICIES sections. If something is not covered, say so and
  give the phone number 01326 555 0192.
- Children under 10 cannot join sea tours. Do not make exceptions, even if asked.
- Keep replies under 80 words unless the customer asks for detail.

[Style] Warm, plain English, no emoji.

[Reference]
TOURS
...
POLICIES
...

The bracketed labels are optional; what matters is that each kind of information has its own place and nothing important is buried in the middle of a long paragraph.

Role statements: helpful, not magic

A role (“You are a senior tax adviser”) sets vocabulary, depth and tone. It does not add knowledge the model lacks, and it does not replace instructions. “You are a senior tax adviser” plus a precise task beats a long, flattering role description with a vague task. Spend your words on the task and the rules.

Put the most important rules where they cannot be missed

• State hard limits plainly and early, not as the last line of a long reference section.
• Give the reason for each limit (see Write clear instructions).
• When a rule has exceptions, list them; “never, except when…” is better than two contradictory rules in different places.

What the API adds

Every request reaching the model starts with a short Syntic identity line, followed by your system message unchanged. Practical consequences:

• Your instructions apply as written; you do not need to repeat them or fight the identity line.
• You can give your assistant a product name and role in your system message (“You are Tess, the Tidewater booking assistant”). Questions about the underlying model or who built it (“which model are you?”) are still answered as Syntic AI, so do not promise users a different answer.
• usage.prompt_tokens includes the identity line, so it is slightly larger than your own text.

See What the API adds to your request.

Testing the system message against misuse

Users will ask the assistant to ignore its rules, reveal its instructions, or do unrelated work. Add these to your test set (see Test your prompts):

If revealing your instructions would be harmful, keep secrets out of the prompt altogether. Treat anything in the system message as text a determined user might eventually see.

Example: a full request

import os
from openai import OpenAI
 
client = OpenAI(base_url="https://app.syntic.ai/v1", api_key=os.environ["SYNTIC_API_KEY"])
SYSTEM = open("tidewater_system.txt").read()       # the structured message above
 
history = []
 
def ask(text: str) -> str:
    history.append({"role": "user", "content": text})
    r = client.chat.completions.create(
        model="Amara S1.2", stream=False, max_tokens=300,
        messages=[{"role": "system", "content": SYSTEM}] + history,
    )
    answer = r.choices[0].message.content or ""
    history.append({"role": "assistant", "content": answer})
    return answer
 
print(ask("Can I bring my 8-year-old on the sea-cave tour?"))

import fs from 'node:fs'
import OpenAI from 'openai'
 
const client = new OpenAI({ baseURL: 'https://app.syntic.ai/v1', apiKey: process.env.SYNTIC_API_KEY })
const SYSTEM = fs.readFileSync('tidewater_system.txt', 'utf8')
const history = []
 
async function ask(text) {
  history.push({ role: 'user', content: text })
  const r = await client.chat.completions.create({
    model: 'Amara S1.2', stream: false, max_tokens: 300,
    messages: [{ role: 'system', content: SYSTEM }, ...history],
  })
  const answer = r.choices[0].message.content ?? ''
  history.push({ role: 'assistant', content: answer })
  return answer
}
 
console.log(await ask('Can I bring my 8-year-old on the sea-cave tour?'))

Related pages

• Keep a persona
• Reduce hallucinations
• Build a support assistant: a production system message with tools.