Prompt

Prompt Assembly Architecture

The prompt builder is intentionally layered so that stable identity and behavior rules remain cacheable while live session context stays dynamic. That is why Seshat can preserve a durable runtime contract without pretending the whole prompt is static across turns.

The Pre-Existing Prompt Core

Before your application appends or overrides anything, Seshat already ships a substantial default prompt core. It covers identity, runtime contract, working rules, factual discipline, tool usage, workflow, orchestration, examples, and output discipline.

Prompt Parameters And Overrides

These are the practical Go SDK surfaces that shape the prompt. The table deliberately mixes client-level config with session methods because both matter when you design embedded agent behavior.

Structured Prompt Customization

In most products, PromptConfig is the right first tool. It is strong enough to add durable business context, tool-use bias, and custom stage overlays without forcing a full replacement of the shipped runtime contract.

func ptr(value string) *string { return &value }

client, err := sdk.NewClient(&sdk.ClientConfig{
    Model: sdk.ModelIdentifier{
        Provider: sdk.APIProviderAnthropic,
        Model:    "claude-sonnet-4-20250514",
    },
    APIKey: os.Getenv("ANTHROPIC_API_KEY"),
    PromptConfig: &sdk.PromptConfig{
        AppendSystemPrompt: ptr(`Business context:
- Reliability beats speed.
- Migrations must be backward compatible.`),
        ToolHints: map[string]string{
            "bash":        "Prefer inspection commands before mutating commands.",
            "apply_patch": "Keep edits minimal and reviewable.",
        },
        StageOverrides: map[sdk.ExecutionStage]string{
            sdk.StagePlan: `# Stage: plan mode

Tool execution is suspended.
- Produce a concise numbered plan.
- Mention risks and validation steps.
- Do not execute tools.`,
        },
    },
})

Full Override Versus Safe Extension

A full override exists because some host applications genuinely need it, but it should not be your default instinct. Extending the prompt is usually safer than replacing the whole stable contract.

func ptr(value string) *string { return &value }

client, err := sdk.NewClient(&sdk.ClientConfig{
    Model: sdk.ModelIdentifier{
        Provider: sdk.APIProviderAnthropic,
        Model:    "claude-sonnet-4-20250514",
    },
    APIKey: os.Getenv("ANTHROPIC_API_KEY"),
    PromptConfig: &sdk.PromptConfig{
        SystemPrompt: ptr(`You are the internal release-audit runtime.

Rules:
- Be conservative.
- Audit for regressions and rollback risk.
- Return blockers before suggestions.`),
    },
})

Session-Level Prompt Context

Session overrides are the right layer for context that should not affect every future run. Release windows, tenant details, one-off compliance instructions, or temporary operational context belong here.

session, err := client.CreateSession(ctx)
if err != nil {
    log.Fatal(err)
}
defer session.Close()

session.SetAppendSystemPrompt(`Release context:
- branch: release/2026.06
- freeze: active
- production incidents: 0 open`)

_, err = session.SubmitMessage(ctx, "Inspect the auth service for release blockers.")

Execution Stages

Stages are not generic labels. They are real overlays injected into the dynamic prompt layer. You can let the loop infer them when appropriate, or you can pin the stage explicitly from the host side.

client, err := sdk.NewClient(&sdk.ClientConfig{
    Model: sdk.ModelIdentifier{
        Provider: sdk.APIProviderAnthropic,
        Model:    "claude-sonnet-4-20250514",
    },
    APIKey: os.Getenv("ANTHROPIC_API_KEY"),
    PromptConfig: &sdk.PromptConfig{
        Stage: sdk.StagePlan,
    },
})

Project Instructions And Working Directory

The prompt builder also pulls project-level instructions from the active working directory. It checks SESHAT.md, then AGENTS.md, then .seshat/instructions.md, taking the first non-empty file and truncating at 32 KB if needed. This is why working-directory control is part of prompt architecture, not just file-tool setup.

What To Use When

1. Use SystemPromptTemplate for a durable client-level persona.
2. Use AppendSystemPrompt for stable domain or business context.
3. Use ToolHints to nudge tool behavior without rewriting the persona.
4. Use StageOverrides when the built-in plan or continuation wording is not right for your product.
5. Use session overrides for one run, one tenant, one release, or one mission.
6. Use a full override only when you intentionally want to replace the shipped stable contract.

Related Pages

Continue with Agent for persona and role patterns, Tools & Surface for the action layer, or Mono-Run Architecture for the runtime-side view behind this prompt assembly.