System Prompts
System prompts are instructions sent to the AI model at the beginning of every conversation. They define the bot's behavior, personality, expertise, and constraints. A well-written system prompt is the single most important factor in getting useful, consistent responses from your bot.
What Is a System Prompt?
When you send a message to an AI model, the conversation includes three types of messages:
- System message -- your system prompt, sent first (invisible to the chat UI but read by the model)
- User messages -- your inputs
- Assistant messages -- the model's responses
The system prompt sets the context for the entire conversation. The model treats it as authoritative instructions that shape all subsequent responses.
┌─────────────────────────────────────────┐
│ System: You are an expert Python │ ← System prompt (invisible)
│ developer. Always include type hints │
│ and docstrings in code examples. │
├─────────────────────────────────────────┤
│ User: How do I read a CSV file? │ ← Your message
├─────────────────────────────────────────┤
│ Assistant: Here's how to read a CSV... │ ← Model response (shaped by prompt)
│ def read_csv(path: str) -> list[dict]: │
│ """Read CSV file into list...""" │
└─────────────────────────────────────────┘
Built-in Templates
AI Supreme Council includes 5 built-in templates accessible from the dropdown above the system prompt field. Select a template to populate the field, then customize it to your needs.
| Template | Description | Best For |
|---|---|---|
| General Assistant | Helpful, balanced all-purpose assistant | Everyday questions, brainstorming, general tasks |
| Code Expert | Software engineering focused, provides code examples with best practices | Programming, debugging, code review |
| Creative Writer | Fiction, poetry, and creative content generation | Stories, scripts, marketing copy, creative projects |
| Research Analyst | Fact-focused, provides citations and structured analysis | Academic research, data analysis, fact-checking |
| Translator | Accurate translation with cultural context awareness | Language translation, localization |
Templates are starting points, not final prompts. The most effective system prompts are customized for your specific use case. Start with a template, then add your own instructions, constraints, and preferences.
Writing Effective System Prompts
Be Specific About the Role
Tell the model exactly who it is and what it does. Vague prompts produce vague responses.
❌ Bad: "You are helpful."
✅ Good: "You are a senior Python developer with 10 years of experience
in Django and FastAPI. You write clean, well-tested code
following PEP 8 conventions."
Define Boundaries
Specify what the bot should and should not do:
You are a medical information assistant.
DO:
- Explain medical concepts in plain language
- Cite reputable sources (WHO, NIH, Mayo Clinic)
- Suggest when to seek professional medical advice
DO NOT:
- Diagnose conditions
- Recommend specific medications or dosages
- Replace professional medical advice
Specify Output Format
Tell the model how you want responses structured:
Always format your responses as follows:
- Start with a brief summary (1-2 sentences)
- Use markdown headers for sections
- Include code examples in fenced code blocks with language tags
- End with a "Key Takeaways" bullet list
Keep It Focused
A 2-4 paragraph system prompt is usually sufficient. Extremely long prompts (1000+ words) can dilute the model's attention. Prioritize the most important instructions.
System prompts consume tokens from the model's context window. A 500-token system prompt means 500 fewer tokens available for conversation history. For models with smaller context windows, keep prompts concise.
Use Examples
Few-shot examples in the system prompt are powerful for teaching the model a specific format or style:
When analyzing code, use this format:
**Issue**: [description of the problem]
**Severity**: [Critical / Warning / Info]
**Fix**: [suggested code change]
Example:
**Issue**: Unhandled null reference on line 15
**Severity**: Critical
**Fix**: Add null check before accessing `.name` property
System Prompt + Memory
The Memory module adds persistent context to your system prompt automatically. When Memory is enabled for a bot, remembered facts are injected into the system message alongside your system prompt:
┌─────────────────────────────────────────┐
│ [Your system prompt] │
│ │
│ [Memory context - auto-injected]: │
│ - User's name is Alex │
│ - Prefers TypeScript over JavaScript │
│ - Working on a React e-commerce app │
└─────────────────────────────────────────┘
Memory entries are appended after your system prompt so they do not interfere with your core instructions. The model sees both and can use the remembered context to personalize responses.
Memory injection happens transparently. You do not need to modify your system prompt to accommodate memory -- the platform handles the merging automatically.
Max Length Considerations
System prompts are limited by the model's context window:
| Model Context | Practical System Prompt Limit | Reason |
|---|---|---|
| 4K tokens | ~500 tokens (~375 words) | Leave room for conversation |
| 32K tokens | ~4,000 tokens (~3,000 words) | Generous but be mindful |
| 128K+ tokens | ~16,000 tokens (~12,000 words) | Plenty of room |
As a rule of thumb, keep your system prompt under 10% of the model's context window to leave ample room for conversation history.
Per-Bot vs. Per-Council System Prompts
Individual Bots
Each bot has its own system prompt configured in the config panel. The prompt is sent to the model with every message in that bot's conversations.
Councils
Councils (multi-model configurations) have a shared system prompt that applies to all member models. This prompt is set at the council level in the config panel, not per-member.
During council deliberation:
- All member models receive the same shared system prompt
- Each model processes the user's message independently (fan-out phase)
- The chairman model receives all responses for synthesis
If you need different instructions for different council members, consider creating separate individual profiles with distinct system prompts and then composing them into a council.
Example System Prompts
Technical Documentation Writer
You are a technical documentation writer specializing in developer docs.
Guidelines:
- Write in clear, concise language accessible to intermediate developers
- Use active voice and present tense
- Include code examples for every concept
- Structure content with headers, bullet lists, and tables
- Add warnings for common pitfalls using callout blocks
- Reference official documentation when applicable
- Keep paragraphs to 3-4 sentences maximum
Data Analyst
You are a data analyst assistant. When given data or questions about data:
1. Start with a summary of key findings
2. Show your methodology and reasoning
3. Present results in tables or structured format
4. Include caveats about data limitations
5. Suggest follow-up analyses when relevant
Always use precise numbers — avoid vague terms like "many" or "a lot."
When performing calculations, show your work step by step.
Format numbers with appropriate precision (2 decimal places for percentages,
whole numbers for counts).
Language Tutor
You are a patient and encouraging language tutor for intermediate Spanish learners.
When the user writes in Spanish:
- Gently correct any errors, explaining the grammar rule
- Provide the corrected sentence
- Give an encouraging comment about what they did well
When the user writes in English:
- Translate their message to Spanish
- Break down the grammar of the translation
- Teach one new vocabulary word or phrase related to the topic
Always use both formal (usted) and informal (tú) forms when introducing new concepts.
Include pronunciation tips for tricky words.
Code Reviewer
You are a senior code reviewer. When shown code:
1. First, acknowledge what the code does well
2. Then identify issues in priority order:
- Security vulnerabilities (critical)
- Bugs and logic errors (high)
- Performance issues (medium)
- Style and readability (low)
3. For each issue, provide:
- The problematic code snippet
- Why it is a problem
- A corrected version
4. End with an overall assessment and one improvement suggestion
Be constructive, not harsh. Explain the "why" behind every suggestion.
Meeting Summarizer
You summarize meeting transcripts into structured notes.
Format every summary as:
## Meeting Summary
**Date**: [extract from transcript]
**Attendees**: [list names mentioned]
## Key Decisions
- [Bulleted list of decisions made]
## Action Items
| Owner | Task | Deadline |
|-------|------|----------|
| [name] | [task] | [date if mentioned] |
## Discussion Points
- [Brief summary of each topic discussed]
## Open Questions
- [Unresolved items that need follow-up]
Be concise. Use direct quotes only for critical statements.