Building toward an open standard for Agentic State, where every automated decision will be bound to law, signed and explainable. Current implementation provides Decision Engineering foundation with basic policy-as-code capabilities, legal compliance framework, and extensible architecture for future agentic features.

# Clone and install (minimal dependencies)
git clone https://github.com/your-org/policy-as-code.git
cd policy-as-code
pip3 install -e .

# Initialize and run your first decision
policy-as-code init
python3 examples/simple_demo.py

That's it! You now have a working Policy as Code system. 🎉

Policy as Code transforms business rules into executable, auditable software. Think of it as "Git for business decisions" - every decision is:

• ✅ Versioned - Track changes over time
• ✅ Testable - Automated testing and validation
• ✅ Auditable - Complete decision history
• ✅ Extensible - Framework for advanced features

Instead of this manual process:

❌ Manual: "Check if income > $50k and credit score > 700"
❌ Manual: "Write decision in Word document"
❌ Manual: "Email to manager for approval"
❌ Manual: "Store in filing cabinet"

You get this automated process:

✅ Code: def loan_approval(data):
✅ Code:   return {"approved": data.income > 50000 and data.credit_score > 700}
✅ Code: # Automatically versioned, tested, and auditable

• CLI Interface - Deploy, execute, and manage decision functions
• Basic Decision Functions - Simple business logic with validation
• Working Examples - Loan approval, basic approval, multi-criteria decisions
• Progressive Learning - Step-by-step examples that actually work
• Extensible Architecture - Ready for advanced features

• Legal Compliance Framework - Finlex/EUR-Lex integration
• Digital Signatures - Change control and separation of duties
• Immutable Trace Ledger - Hash-chained audit trail
• Agentic AI Integration - LLM-powered reasoning

• EU AI Act Compliance - High-risk system compliance
• Cross-Border Architecture - EU AI Commons implementation
• Citizen Explanation API - Human-readable decision justifications
• Advanced Governance - Drift detection and independent audit

python3 examples/simple_demo.py

What you'll learn: Simple decision structure, input/output validation, basic business rules

policy-as-code init
policy-as-code deploy loan_approval 1.0 examples/simple_demo.py
policy-as-code execute loan_approval '{"credit_score": 750, "income": 75000}'

What you'll learn: Function deployment, execution, registry management

python3 examples/level1_basic_approval.py
python3 examples/level1_loan_approval.py

What you'll learn: Complex business logic, multiple criteria, error handling

• python3 examples/opa_demo.py - Shows Python-OPA bridge
• OPA/Rego policy integration
• Integration challenges and solutions

def loan_approval(input_data):
    """Simple loan approval logic"""
    credit_score = input_data.get("credit_score", 0)
    income = input_data.get("income", 0)

    if credit_score >= 700 and income >= 50000:
        return {"approved": True, "amount": min(income * 3, 500000)}
    else:
        return {"approved": False, "reason": "Criteria not met"}

# Deploy your function
policy-as-code deploy loan_approval 1.0 loan_approval.py

# Execute with real data
policy-as-code execute loan_approval '{"credit_score": 750, "income": 75000}'

• ✅ Input Validation - Automatic data validation
• ✅ Output Validation - Consistent response format
• ✅ Audit Trail - Every decision is logged
• ✅ Version Control - Track changes over time
• ✅ CLI Management - Easy deployment and execution

• Social Benefits - Automated welfare eligibility
• Tax Calculation - Complex tax computations
• Immigration - Visa processing workflows
• Healthcare - Medical procedure eligibility

• Loan Approval - Credit risk assessment
• Insurance - Policy underwriting
• Compliance - Regulatory requirement checking
• Fraud Detection - Risk scoring algorithms

• HR Policies - Employee benefit calculations
• Pricing Rules - Dynamic pricing logic
• Approval Workflows - Multi-step decision processes
• Compliance - Regulatory requirement validation

Every decision is cryptographically signed and stored in an append-only ledger.

Built-in support for legal references (Finlex, EUR-Lex) and EU AI Act compliance.

LLM integration for complex decision-making and natural language explanations.

Real-time metrics, alerting, and comprehensive analytics.

CLI, REST API, GraphQL, WebSocket, and Python SDK for any integration need.

┌─────────────────────────────────────────────────────────────┐
│                    Policy as Code Foundation                │
├─────────────────────────────────────────────────────────────┤
│ • CLI Interface      • Decision Engine                      │
│ • Basic Validation   • Function Registry                    │
│ • Working Examples   • Extensible Framework                 │
│ • Documentation      • Future-Ready Architecture           │
└─────────────────────────────────────────────────────────────┘

git clone https://github.com/your-org/policy-as-code.git
cd policy-as-code
pip3 install -e .
policy-as-code init
python3 examples/simple_demo.py

1. Level 1: python3 examples/simple_demo.py
2. Level 2: Use CLI to deploy and execute functions
3. Level 3: Try multi-criteria examples
4. Level 4: Build your own decision function

# Install with production dependencies
pip3 install -e ".[production]"

# Start API server
python3 bin/run_api.py

• Getting Started: Complete Guide
• Architecture: System Overview
• CLI Reference: Command Documentation
• Questions: Open a GitHub issue
• Contributing: See Contributing Guide

• Getting Started Guide - Complete learning path
• Architecture Overview - System design
• CLI Reference - Command-line interface
• API Reference - REST API documentation
• Full Documentation - Complete reference

We welcome contributions! See our Contributing Guide for details.

git clone https://github.com/your-org/policy-as-code.git
cd policy-as-code
pip3 install -e ".[dev]"
make test
make lint

This project is licensed under the MIT License - see the LICENSE file for details.

We're building the foundation for accountable automation.

This Policy as Code foundation provides the essential building blocks for transforming governance - from manual, error-prone processes to automated, auditable, and intelligent decision-making systems.

• ✅ Working Foundation - Basic decision functions with validation and testing
• ✅ CLI Interface - Easy deployment and execution of decision functions
• ✅ Extensible Architecture - Ready for legal compliance and agentic features
• ✅ Clear Roadmap - Path toward Agentic State with legal binding
• ✅ Open Source - MIT licensed for maximum adoption

Ready to start building accountable automation? Get started now! 🚀

• ✅ Basic decision functions with validation
• ✅ CLI interface for function management
• ✅ Working examples and documentation
• ✅ Extensible architecture

• 🔄 Finlex/EUR-Lex integration
• 🔄 Legal reference validation
• 🔄 EU AI Act compliance framework
• 🔄 Digital signature infrastructure

• 🔮 LLM integration for reasoning
• 🔮 Conversational interfaces
• 🔮 Workflow orchestration
• 🔮 Multi-agent coordination

• 🔮 EU AI Commons implementation
• 🔮 Nordic-Baltic pioneer deployment
• 🔮 Multilingual AI support
• 🔮 Cross-border APIs

Built with ❤️ for the future of accountable automation