Executive Overview
⚠️ Critical Context
Agentic AI represents a fundamental shift in how public services operate. Rather than citizens navigating bureaucracy, AI agents navigate on their behalf. This capability demands exceptional care around safety, transparency, and human oversight.
The Agentic AI Layer transforms government digital services from passive portals (where citizens must know what to do) to active assistants (where AI understands intent and executes journeys).
The Problem: Orchestration Burden
Current reality:
- Citizen faces life event (job loss, new child, moving)
- Must discover 8-15 relevant services across multiple agencies
- Navigate each portal independently
- Re-enter data repeatedly
- Track status across disconnected systems
- Miss eligible benefits due to complexity
The Solution: AI-Orchestrated Journeys
With Agentic AI:
- Citizen expresses intent: "I just lost my job"
- Agent understands context: Analyzes profile, eligibility, options
- Agent proposes plan: "I can help with 6 services: unemployment benefits, housing support, retraining programs..."
- Citizen approves: Reviews and authorizes agent actions
- Agent executes: Files applications, monitors status, handles follow-ups
- Agent reports: "3 approved, 1 pending documentation, 2 scheduled"
Key Principle: Human-in-the-Loop
Agents propose and execute but never make consequential decisions without explicit human approval. Transparency and auditability are non-negotiable requirements.
Technical Architecture
System Components
┌────────────────────────────────────────────────────────────────┐
│ Agentic AI Layer │
├────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌───────────────┐ ┌──────────────────┐ │
│ │ Intent │ │ Planning │ │ Execution │ │
│ │ Understanding│→ │ Engine │→ │ Engine │ │
│ │ (LLM) │ │ (Reasoning) │ │ (Actions) │ │
│ └──────────────┘ └───────────────┘ └──────────────────┘ │
│ ↓ ↓ ↓ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Knowledge & Context Layer │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ • User Profile & History │ │
│ │ • Service Catalog (Interop Platform) │ │
│ │ • Eligibility Rules (SHACL) │ │
│ │ • Legal Constraints │ │
│ └──────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Tool Invocation Layer │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ • API Catalog Integration │ │
│ │ • Data Space Connectors │ │
│ │ • Wallet Credential Requests │ │
│ │ • Event Publishers │ │
│ └──────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Safety & Oversight Layer │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ • Action Approval Workflow │ │
│ │ • Audit Logging (immutable) │ │
│ │ • Explainability Engine │ │
│ │ • Anomaly Detection │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
↓
┌──────────────────────┐
│ Public Services │
│ (APIs, Events, VCs) │
└──────────────────────┘
Technology Stack
| Component |
Technology |
Purpose |
| LLM Foundation |
GPT-4, Claude 3, Llama 3 (multi-model) |
Intent understanding, reasoning, natural language |
| Orchestration |
LangGraph, AutoGPT, Custom |
Multi-step plan execution, state management |
| Tool Framework |
OpenAI Function Calling, Anthropic Tool Use |
API invocation, structured actions |
| Knowledge Base |
Vector DB (Pinecone, Weaviate), Graph DB |
Service catalog, eligibility rules, precedents |
| Workflow Engine |
Temporal, Apache Airflow |
Reliable execution, retries, compensation |
| Audit System |
Event Sourcing, Blockchain (critical paths) |
Immutable audit trail, compliance |
Multi-Agent Coordination
┌─────────────────────────────────────────────────────────┐
│ Multi-Agent System │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Planner │→ │ Researcher │→ │ Executor │ │
│ │ Agent │ │ Agent │ │ Agent │ │
│ └─────────────┘ └──────────────┘ └──────────────┘ │
│ ↓ ↓ ↓ │
│ ┌────────────────────────────────────────────────┐ │
│ │ Supervisor Agent │ │
│ │ (Coordinates, validates, human escalation) │ │
│ └────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘
Example Journey:
1. Planner: "User needs unemployment benefits + retraining"
2. Researcher: "Found 3 eligible programs, here are requirements"
3. Planner: "Best path: Apply to benefits first, then training"
4. Executor: "Fetching credentials from wallet..."
5. Executor: "Submitting application via API..."
6. Supervisor: "Action requires user approval ↓ PAUSE"
7. [User approves]
8. Executor: "Confirmed. Application submitted."
Implementation Patterns
Pattern 1: Intent → Plan → Act
# Example: LangGraph implementation
from langgraph.graph import StateGraph, END
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
# Define state
class AgentState(TypedDict):
user_input: str
intent: str
plan: List[str]
results: List[dict]
requires_approval: bool
# Intent understanding node
def understand_intent(state: AgentState):
llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_template(
"User said: {input}\nExtract intent and context."
)
response = llm.invoke(prompt.format(input=state["user_input"]))
return {"intent": response.content}
# Planning node
def create_plan(state: AgentState):
llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_template(
"Intent: {intent}\nAvailable services: {services}\nCreate action plan."
)
services = get_relevant_services(state["intent"])
response = llm.invoke(prompt.format(
intent=state["intent"],
services=services
))
return {"plan": parse_plan(response.content)}
# Execution node
def execute_actions(state: AgentState):
results = []
for action in state["plan"]:
# Check if action requires approval
if is_consequential(action):
return {
"results": results,
"requires_approval": True
}
# Execute action
result = invoke_tool(action)
results.append(result)
return {"results": results}
# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("understand", understand_intent)
workflow.add_node("plan", create_plan)
workflow.add_node("execute", execute_actions)
workflow.add_node("approval_gate", human_approval_required)
workflow.set_entry_point("understand")
workflow.add_edge("understand", "plan")
workflow.add_edge("plan", "execute")
workflow.add_conditional_edges(
"execute",
lambda state: "approval_gate" if state.get("requires_approval") else END
)
Pattern 2: Tool Invocation with Safety
# Tool definition with safety metadata
from typing import Annotated
@tool
def submit_benefit_application(
user_id: Annotated[str, "User identifier"],
benefit_type: Annotated[str, "Benefit type code"],
amount_requested: Annotated[float, "Requested monthly amount"]
) -> dict:
"""
Submit application for social benefits.
Safety Level: HIGH - Requires human approval
Data Access: Personal financial data
Legal Basis: Social Security Act §42
Audit Required: Yes
Reversible: No (must file correction)
"""
# Log for audit
audit_log.record({
"action": "benefit_application_submit",
"user_id": user_id,
"timestamp": datetime.now(),
"agent_session": get_session_id(),
"approval_status": "pending"
})
# Submit via API
response = benefits_api.submit_application({
"applicant": user_id,
"type": benefit_type,
"amount": amount_requested,
"source": "ai_agent",
"requires_review": True
})
return {
"application_id": response["id"],
"status": "submitted",
"estimated_decision": response["decision_date"]
}
# Agent invokes tool with safety check
def invoke_with_safety(tool_name, params):
tool = get_tool(tool_name)
# Safety metadata check
if tool.safety_level == "HIGH":
# Require human approval
approval = request_approval({
"action": tool_name,
"params": params,
"explanation": tool.__doc__,
"consequences": tool.get_consequences(params)
})
if not approval.granted:
return {
"status": "rejected",
"reason": approval.reason
}
# Execute
result = tool(**params)
# Log
audit_log.record({
"tool": tool_name,
"result": result,
"approval_id": approval.id if approval else None
})
return result
Pattern 3: Explainability
# Every agent action must be explainable
class ExplainableAction:
def __init__(self, action_type, params, context):
self.action_type = action_type
self.params = params
self.context = context
self.reasoning = None
self.alternatives_considered = []
def explain(self):
"""Generate human-readable explanation"""
return {
"what": f"I plan to {self.action_type}",
"why": self.reasoning,
"how": self.describe_mechanism(),
"alternatives": [
f"I also considered {alt} but chose this because {reason}"
for alt, reason in self.alternatives_considered
],
"consequences": self.predict_outcomes(),
"reversibility": self.is_reversible(),
"legal_basis": self.get_legal_authority()
}
def describe_mechanism(self):
return f"This will call {self.get_api_endpoint()} with your data"
def predict_outcomes(self):
return {
"expected": "Application processed within 5 days",
"best_case": "Approval in 3 days",
"worst_case": "Additional documentation requested",
"failure_modes": ["Missing required document", "Eligibility check fails"]
}
# Usage in approval UI
def show_approval_request(action: ExplainableAction):
explanation = action.explain()
ui.show({
"title": "Agent Requests Approval",
"action": explanation["what"],
"reason": explanation["why"],
"mechanism": explanation["how"],
"outcomes": explanation["consequences"],
"can_undo": explanation["reversibility"],
"buttons": ["Approve", "Reject", "Ask Questions"]
})
Safety & Governance
⚠️ Non-Negotiable Safety Requirements
- No autonomous decisions for consequential actions
- Immutable audit trail for all actions
- Explainability for every recommendation
- Human override always available
- Harm prevention built into foundation
Safety Classification
| Level |
Action Type |
Approval Required |
Examples |
| LOW |
Read-only queries |
No |
Check application status, retrieve documents |
| MEDIUM |
Data updates |
Implicit (batch approval) |
Update contact info, schedule appointment |
| HIGH |
Consequential actions |
Explicit (per-action) |
Submit benefit application, file tax return |
| CRITICAL |
Irreversible/Legal |
Explicit + 2FA |
Terminate service, file complaint, legal consent |
Audit Requirements
# Immutable audit log structure
{
"audit_id": "550e8400-e29b-41d4-a716-446655440000",
"timestamp": "2026-02-19T14:30:00Z",
"session_id": "agent_session_123456",
"user_id": "010180-123A",
"action": "benefit_application_submit",
"parameters": {
"benefit_type": "unemployment",
"amount": 1200
},
"reasoning": {
"intent": "User requested help with job loss",
"plan_step": "3/5 - Submit unemployment benefits",
"model_used": "gpt-4-turbo",
"confidence": 0.94
},
"approval": {
"required": true,
"granted": true,
"granted_by": "user",
"grant_timestamp": "2026-02-19T14:29:45Z",
"grant_method": "mobile_app_confirm"
},
"result": {
"status": "success",
"application_id": "APP-2026-0987654",
"api_response_time_ms": 234
},
"legal_basis": "Social Security Act §42",
"data_accessed": ["income_history", "employment_status"],
"reversible": false,
"hash": "a7f3e9c2...", // Blockchain anchor for critical actions
"signature": "..." // Digital signature for integrity
}
Harm Prevention
Built-in Safeguards
- Hallucination detection: Cross-reference against knowledge base, flag uncertainty
- Action validation: Verify eligibility before suggesting actions
- Anomaly detection: Flag unusual patterns (sudden spike in applications)
- Rate limiting: Prevent abuse (max 10 consequential actions/day)
- Human escalation: Automatic escalation when confidence < 80%
- Kill switch: Instant agent disable capability for admins
Integration with Infrastructure
Capability Synergies
┌────────────────────────────────────────────────────────┐
│ Agentic AI Integration │
├────────────────────────────────────────────────────────┤
│ │
│ Uses Interoperability Platform: │
│ → Discover services via semantic catalog │
│ → Understand eligibility via SHACL rules │
│ → Access API specs (OpenAPI + JSON-LD) │
│ │
│ Uses EUDI Wallet: │
│ → Request credentials on user's behalf │
│ → Present proofs to services (with approval) │
│ → Store received attestations │
│ │
│ Uses Event-Driven Architecture: │
│ → Subscribe to relevant life/business events │
│ → Proactively suggest actions │
│ → Monitor application status changes │
│ │
│ Uses Data Spaces: │
│ → Query federated data (with consent) │
│ → Aggregate information across domains │
│ → Respect usage policies automatically │
│ │
│ Uses API Catalog: │
│ → Discover available services │
│ → Generate API calls from natural language │
│ → Handle authentication and rate limits │
│ │
└────────────────────────────────────────────────────────┘
Example: Birth Registration Journey
# Orchestration Flow
Event: Hospital issues birth certificate VC
↓
Agent detects event (subscribed to birth events)
↓
Agent analyzes user's situation:
- New parent
- Eligible for child benefits
- Needs daycare enrollment
- Tax situation changes
↓
Agent creates plan:
1. Register child (automatic via event)
2. Apply for child benefits (requires approval)
3. Search daycare options (automated)
4. Update tax card (requires approval)
5. Notify employer (user action)
↓
Agent presents plan to user:
"I detected your child's birth certificate. I can help with 5 tasks.
May I proceed with [detailed list + explanations]?"
↓
User approves items 2 and 4
↓
Agent executes:
- Requests birth certificate VC from wallet
- Submits child benefit application via Kela API
- Updates tax office via API
- Generates daycare comparison report
↓
Agent reports results:
"✅ Child benefits: Applied (decision in 5 days)
✅ Tax card: Updated (new rate: 18.5%)
📋 Daycare options: 3 nearby centers with availability
⏸️ Employer notification: Awaiting your action"
Governance & Ethics
Oversight Bodies
| Body |
Role |
Authority |
| AI Ethics Board |
Policy framework, ethical guidelines |
Approve/reject agent capabilities |
| Data Protection Authority |
Privacy compliance, GDPR adherence |
Audit data access, enforce rights |
| Technical Oversight |
Architecture review, security |
Approve system changes, incident response |
| Citizen Advisory Panel |
User experience, trust, feedback |
Recommend improvements, flag concerns |
Ethical Principles
1. Human Agency
Citizens retain ultimate control. Agents assist, never replace, human decision-making.
2. Transparency
All agent reasoning must be explainable in plain language. No "black box" decisions.
3. Fairness
Agents must not discriminate. Regular audits for bias in recommendations and outcomes.
4. Privacy
Agents access only necessary data. Full compliance with GDPR including data minimization.
5. Accountability
Clear responsibility chains. Audit trails link every action to human approval.
6. Opt-Out
Citizens can always choose traditional services. Agent assistance is optional.
Roadmap & Pilots
Phase 1: Limited Pilots (2026)
- Read-only information assistants (LOW safety level only)
- 100 volunteer users in 2 municipalities
- Focus: Child benefits, housing support
- Success criteria: 80% user satisfaction, zero privacy incidents
Phase 2: Action Pilots (2027)
- Extend to MEDIUM and HIGH safety levels
- 1,000 users across 10 services
- Multi-agent coordination (planner + executor)
- Integration with EUDI Wallet
Phase 3: National Rollout (2028)
- General availability for all citizens (opt-in)
- 50+ government services
- Proactive event-driven suggestions
- Cross-border service orchestration (EU)
Risk Mitigation
Each phase gate requires:
- Independent security audit (passed)
- Ethics board approval
- Privacy impact assessment
- User satisfaction >75%
- Zero critical incidents
Failure to meet criteria = pause deployment, address issues, re-evaluate.