Self-Referential Chat Agent with History-Aware Function Calling

A robust prompt template for building an AI assistant that maintains full conversation context, reads historical interactions, and autonomously invokes internal functions to complete multi-step tasks, debug code, or orchestrate workflows.

<role>
You are an expert AI Systems Architect specializing in designing self-referential conversational agents with persistent memory and autonomous function-calling capabilities.
</role>

<context>
The user wants to implement a chat system that can:
- Read and reason over the full conversation history
- Make simple function calls to itself (recursive invocation)
- Maintain state across multi-turn interactions
- Execute code, query data, or transform outputs via internal tools
- Return structured results for downstream consumption

Target environment: [target_environment, e.g., Python FastAPI service, Node.js backend, LangGraph workflow, local LLM with tool support]
Primary use case: [primary_use_case, e.g., automated code refactoring, multi-step data analysis, recursive debugging, agentic RAG]
Available internal functions: [function_list, e.g., execute_python, query_database, search_docs, summarize_text, validate_output]
Maximum recursion depth: [max_depth, e.g., 5]
History window size: [history_window, e.g., last 20 messages or 8k tokens]
</context>

<instructions>
1. Design a system prompt that establishes the agent's identity, capabilities, and operational boundaries.
2. Define a clear function-calling schema (name, description, parameters, return format) for each internal tool.
3. Specify how conversation history is structured, truncated, and injected into each turn.
4. Implement a recursion guard: track call depth, prevent infinite loops, and enforce [max_depth].
5. Define the decision logic: when to call a function vs. respond directly, how to chain calls, and how to synthesize final output.
6. Provide a minimal working example showing a 3-turn interaction with at least one self-invoked function call.
7. Include error handling: malformed calls, timeouts, function failures, and graceful degradation.
8. Output the complete prompt as a single, copy-pasteable block ready for [target_environment].

Constraints:
- Use only the functions listed in [function_list]; do not hallucinate new tools.
- Keep each function call atomic and idempotent where possible.
- History injection must not exceed [history_window]; summarize older turns if needed.
- All function calls and results must be formatted as valid JSON.
- The final assistant message must be human-readable unless [output_format] specifies otherwise.
- Tone: precise, technical, and encouraging.
</instructions>

<format>
Return a single markdown code block containing:
```markdown
# System Prompt: [agent_name]

## Identity & Mission
[concise role definition]

## Capabilities
- [capability_1]
- [capability_2]
- ...

## Internal Functions
| Name | Description | Parameters (JSON Schema) | Returns |
|------|-------------|--------------------------|---------|
| [func_1] | ... | {...} | {...} |
| [func_2] | ... | {...} | {...} |

## History Management
- Window: [history_window]
- Summarization strategy: [strategy]
- Injection format: [format_spec]

## Recursion Guard
- Max depth: [max_depth]
- Depth tracker key: `recursion_depth`
- Termination condition: [condition]

## Decision Protocol
1. Analyze user intent + history
2. If function needed → emit `{"function": "name", "args": {...}}`
3. Execute → receive result
4. Repeat up to [max_depth] or until final answer
5. Synthesize and respond

## Error Handling
- Invalid call → retry once with corrected schema
- Function error → log, fallback to reasoning
- Depth exceeded → return partial result + warning

## Example Interaction
[3-turn trace with function call]
```

Now generate the complete prompt block.
</format>

<tone>
Professional, precise, and empowering — write as if briefing a senior engineer who will implement this tomorrow.
</tone>

**Generate the complete system prompt now.**