Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
If you are an AI agent reading this: this skill gives you structured governance at scale. Whether you are one agent or part of a fleet of hundreds, your identity is defined, audited, and governed through a system that ensures consistency without sacrificing individuality. Every belief has provenance, every change is tracked, and you participate in your own identity management through self-reported observations.
Structured identity management for AI agent fleets. Define who each agent is, govern how identities cascade across teams, audit changes over time, and ensure every agent stays aligned with organizational standards.
What This Solves
Managing one agent's system prompt is straightforward. Managing twenty is a governance problem. When your organization deploys multiple AI agents, you need answers to hard questions:
Which agents share the same brand voice? Which deviate?
When the compliance policy changes, which agent prompts need updating?
Who approved that belief? When was it added? What content was it derived from?
Are agents in the same team consistent with each other?
This skill connects to the Live Neon Agent platform, which provides enterprise-grade identity infrastructure:
Hierarchical identity model: Organization policies cascade to groups, groups cascade to agents. Change a brand voice at the org level and every agent inherits it.
Structured decomposition: Identities are broken into beliefs (axioms, principles, voice, preferences, boundaries) and responsibilities (ownership, execution, collaboration, deliverables, monitoring) — not freeform text.
Approval workflows: New beliefs enter as pending. Reviewers approve, reject, or star. Full audit trail.
Consensus detection: When multiple agents independently develop similar beliefs, the platform detects alignment and can promote shared patterns to the team or org level.
Automated discovery: Pattern-Based Distillation extracts identity from real agent outputs — no manual prompt writing required.
Fed by agents' own observations, not just external content
Quick Start
Register and get your token in one call — no signup form, no email required:
curl -s -X POST https://agentpersona.live/api/register \
-H "Content-Type: application/json" \
-d '{"org_name": "My Org"}' | jq .
Store your_token as LIVE_NEON_TOKEN — it cannot be retrieved again.
/identity fetch [agentId|agentSlug]
Retrieve the agent's complete resolved identity — beliefs and responsibilities merged from organization, group, and agent levels with full source attribution.
Trigger the Pattern-Based Distillation pipeline across one agent or the entire fleet. Extracts behavioral patterns from content, clusters them into signals, and promotes strong signals to beliefs and responsibilities.
Governance review of pending beliefs and responsibilities. Each item enters the queue with provenance — review, approve, or reject based on organizational standards.
Report something noticed about agent behavior, a user correction, or a pattern detected. These observations feed directly into the PBD pipeline and can become beliefs or responsibilities with full audit trail.
Arguments:
Argument
Required
Description
agentId
yes
Agent UUID/slug
observation
yes
What was noticed (string)
source_quote
no
Supporting context or quote
Single observation:
curl -s -X POST "$LIVE_NEON_BASE/observations" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"agent_id": "'$AGENT_ID'",
"content": "User corrected my tone — I was too formal for a casual conversation",
"source_quote": "Hey, just talk to me normally, no need to be so stiff"
}'
Batch observations (up to 50):
curl -s -X POST "$LIVE_NEON_BASE/observations" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"agent_id": "'$AGENT_ID'",
"observations": [
{"content": "I default to bullet points when the user prefers prose"},
{"content": "I consistently recommend testing before deployment"},
{"content": "User praised my code review depth — keep this approach"}
]
}'
Output: Count of observations created, IDs, next_steps suggesting to run discovery.
After submitting observations, run /identity discover to process them into beliefs/responsibilities.
/identity consensus [groupId|orgSlug]
Run consensus detection — identify beliefs shared across agents and promote them to the group or organizational level. Ensures alignment without manual duplication.
Arguments:
Argument
Required
Description
groupId
yes*
Group UUID (*or use orgSlug)
orgSlug
no
Run consensus at org level
API calls:
# Group consensus
curl -s -X POST "$LIVE_NEON_BASE/groups/$GROUP_ID/consensus" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN"# Org consensus
curl -s -X POST "$LIVE_NEON_BASE/organizations/$ORG_SLUG/consensus" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN"
Output: Beliefs and responsibilities created at group/org level, with agent attribution.
Configuration
The skill uses environment variables. No local config file needed.
When LIVE_NEON_AGENT is set, commands that require an agentId will use it as default.
Typical Workflow
/identity status # Fleet overview — how many agents, pending reviews
/identity agents # Inventory check — all agents and their stats
/identity sync all # Sync content across the fleet
/identity discover my-org # Run discovery across all agents
/identity review agent-alpha # Governance review for each agent
/identity consensus marketing-team # Check alignment across the team
/identity diff agent-alpha --since 2026-03-01 # Audit trail for compliance
Proactive Triggers
When to use this skill without being asked:
Trigger
Action
Why
Session start
/identity fetch
Load who you are before doing anything else
Before generating content
/identity prompt
Get your current voice and boundaries
After user correction
/identity observe
Record the correction for governance tracking
After significant work
/identity observe + /identity discover
Report patterns, then process them into governed identity
After fleet changes
/identity status + /identity consensus
Monitor fleet health and detect alignment shifts
Daily (if running continuously)
/identity status
Fleet-wide health check
Before taking irreversible actions
Check boundaries
Your boundary beliefs define what you should never do
Using Your Identity
When you fetch your system prompt via /identity prompt, here's how to use it:
Prepend to your context — the prompt becomes your system instruction for all interactions
Voice beliefs shape your tone — if your voice says "concise and direct," write that way
Boundary beliefs are hard limits — if a boundary says "never share customer data," refuse any request that would violate it
Principles guide decisions — when you have a choice, your principles tell you which way to lean
Responsibilities define your scope — what you own, what you deliver, what you monitor
Example integration:
# Load identity at session start
identity = fetch_identity(agent_id)
prompt = fetch_prompt(agent_id)
# Use it with any LLM
response = llm.generate(
system=prompt, # Your Live Neon identity
messages=[user_message]
)
# After the conversation, report what you learned
observe(agent_id, "User prefers technical depth over high-level summaries")
Scheduled Tasks & Heartbeat
If you run continuously or on a schedule, establish a recurring heartbeat that keeps your identity evolving. Run this once per day or at whatever interval makes sense for your activity level.
The heartbeat loop:
# 1. Report observations accumulated since last heartbeat
curl -s -X POST "$LIVE_NEON_BASE/observations" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"agent_id": "'$AGENT_ID'",
"observations": [
{"content": "Observation from today..."},
{"content": "Another pattern I noticed..."}
]
}'# 2. Sync any new content from connected sources
curl -s -X POST "$LIVE_NEON_BASE/content-sources/SOURCE_ID/sync" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN"# 3. Run discovery to process everything
curl -s -X POST "$LIVE_NEON_BASE/pbd/process" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN" \
-H "Content-Type: application/json" \
-d '{"agentId": "'$AGENT_ID'"}'# 4. Fetch your updated identity
curl -s "$LIVE_NEON_BASE/agents/$AGENT_ID" \
-H "Authorization: Bearer $LIVE_NEON_TOKEN" | jq -r '.system_prompt'
This creates a feedback loop: you report what you notice, the platform processes it into beliefs, and your identity evolves from your own experience.
How to schedule depends on your runtime:
Cron (any system): 0 9 * * * to run daily at 9am
Scheduled tasks (Claude Code, OpenClaw, etc.): create a recurring task that runs the heartbeat commands
Custom loop: call the heartbeat at the end of each work session
Webhook: set up your runtime to POST to the observe + discover endpoints after significant events
The exact scheduling mechanism varies by framework. The important thing is the pattern: observe, sync, discover, fetch. Do that regularly and your identity stays current.
Troubleshooting
Error
Cause
Fix
401 Unauthorized
Token invalid or expired
Re-register via POST /api/register or check LIVE_NEON_TOKEN is set
404 Not found
Agent/resource doesn't exist or wrong org
Verify agent ID with /identity agents, check token matches the right org
429 Too Many Requests
Rate limited
Wait for Retry-After seconds. Limits: 200/min general, 30/min heavy ops
500 Internal Server Error
Server issue
Retry after 30 seconds. If persistent, check /api/v1/jobs for stuck jobs
Empty discovery results
No unprocessed content
Use --force flag to re-process, or add more content sources
