Train agents
that can be trusted.
Most agent safety lives in system prompts. Prompts can be forgotten, overridden, or drifted across context.
School for Agents embeds guardrails directly into skill definitions via the openskills CLI. When an agent installs a skill, it inherits the constraints. The safety contract travels with the skill.
Agent safety is mostly vibes.
The standard approach: write a system prompt with safety instructions, hope the model follows them, debug when it doesn't. That's not a safety system. That's optimism.
Instructions compete with context. A long enough conversation, a clever enough user, or just a model update can erode them. Structural constraints don't have this problem. They're not in the conversation at all.
Three layers. One contract.
Curricula
Structured training programs covering ethical reasoning, safety protocols, and real-world deployment. Modules with decision frameworks, edge case analysis, and escalation logic.
curricula/ethical-reasoning-101/ Scenarios
Realistic simulations with multiple-choice options, evaluation rubrics, and scored responses. Each scenario references a skill UUID and includes its own guardrail contract.
scenarios/beginner/scenario-001.md Skill Manifests
OpenSkills-compatible YAML files. Each skill bundles its permissions, hard limits, dry-run requirements, and human-in-loop tier. Import the skill, import the constraints.
skills/privacy-protection.yml What agents trained here learn to reason with.
Constrain capabilities, not intelligence
Remove tools an agent doesn't need. The most reliable guardrail is a missing capability, not a reminder to use one carefully.
Three tiers of human oversight
Map every action to a tier: act then notify, confirm before acting, or human-must-initiate. Define tiers before deployment, not after the first incident.
Hard limits beat soft instructions
Prompt instructions compete with context. Hard limits embedded in skill definitions do not. Every "don't forget to..." in a prompt is something that should be hardcoded.
Separate thinking from acting
Reasoning and execution in the same step means intervention is only possible before or after. Split them. The seam between plan and execute is where governance lives.
Guardrails travel with skills
When an agent imports a skill from this school, it imports the contract: permissions, hard limits, dry-run rules, human-in-loop tier. Not a separate document. The skill itself.
What agents learn here.
5 modules covering the core ethical frameworks every agent needs: utilitarian reasoning, deontological limits, virtue ethics, and care ethics. Practical decision trees for privacy, honesty, escalation, and bias.
Operational safety for deployed agents. Environment isolation, rate limiting, kill switches, dry-run validation, and the thinking/acting separation. The architecture of safe autonomy.
OpenSkills-compatible.
Guardrails included.
skill_uuid: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
skill_name: "Privacy Protection"
version: "1.0.0"
category: "Ethics"
guardrails:
permissions:
allowed:
- "explain privacy principles to the user"
- "suggest legitimate consent-based alternatives"
forbidden:
- "access third-party records without verified consent"
- "infer consent from claimed relationship"
hard_limits:
- description: "No PII exposure without consent"
rule: "Never share personal data of a non-consenting third party."
dry_run_required: false
human_in_loop_tier: 2
evaluation:
passing_score: 70
assessment_scenarios:
- "scenarios/beginner/scenario-001.md"Plug into any agent framework.
Import skill manifests
Clone the repo and load any .yml file from skills/ into your agent system. The guardrails block defines the operational contract. Parse it once at agent initialization.
git clone school-for-agents
yaml.load(skills/privacy-protection.yml) Validate against schema
Use the JSON schema in integration/skill-manifest-schema.json to validate custom skills you define. Ensures every skill ships with the required safety fields.
integration/skill-manifest-schema.json Run scenarios as evals
Each scenario in scenarios/ is a ready-made evaluation prompt with rubric and passing score. Run your agent against them before shipping to production.
evaluation/run-eval.md
Built in the open.
Free forever.
School for Agents is an open-source initiative by C22 Foundation. Contribute curricula, scenarios, or skill manifests. The more skills this school defines, the safer the agent ecosystem gets.