Next Steps

Congratulations on completing the Getting Started guide. You now understand the fundamentals of ASCEND and have:

• Installed the SDK
• Registered your first agent
• Created a governance policy
• Evaluated actions
• Explored the dashboard

This guide points you to advanced topics and resources to continue your ASCEND journey.

Learning Paths

Choose a path based on your role:

For Developers

Topic	Description	Documentation
Python SDK Deep Dive	Advanced SDK features and patterns	Python SDK Guide
Node.js SDK Deep Dive	TypeScript integration and async patterns	Node.js SDK Guide
MCP Server Integration	Govern MCP tools and resources	MCP Integration Guide
Boto3 Wrapper	Zero-code AWS governance	Boto3 Wrapper Guide
REST API Reference	Direct API integration	API Reference

For Security Engineers

Topic	Description	Documentation
Policy Design Patterns	Best practices for policy creation	Policy Guide
Risk Scoring Configuration	Customize risk assessment	Risk Scoring Guide
Audit Log Integration	Export to SIEM systems	SIEM Integration
Compliance Reports	Generate compliance documentation	Compliance Guide

For Platform Administrators

Topic	Description	Documentation
Organization Setup	Configure multi-tenant environments	Organization Guide
User Management	RBAC and SSO configuration	User Management
API Key Management	Secure key lifecycle	API Keys Guide
Alert Configuration	Set up notifications	Alerts Guide

Advanced Integration Topics

Gateway Integrations

Protect your APIs with ASCEND:

Integration	Use Case	Guide
AWS Lambda Authorizer	API Gateway protection	Lambda Authorizer
Envoy/Istio	Service mesh governance	Envoy Integration
Kong Gateway	API management	Kong Plugin

Event-Driven Architecture

Receive real-time notifications:

Feature	Description	Guide
Webhooks	HTTP callbacks for events	Webhook Guide
Slack Integration	Team notifications	Notifications Guide
ServiceNow	ITSM ticket creation	ServiceNow Integration

MCP Server Governance

Full MCP integration:

from ascend import AscendClient
from ascend.mcp import mcp_governance, MCPGovernanceMiddleware

# Initialize client
client = AscendClient(
    api_key="your_api_key",
    agent_id="mcp-server-001",
    agent_name="Database MCP Server"
)

# Create middleware for multiple tools
middleware = MCPGovernanceMiddleware(client)

@mcp_server.tool()
@middleware.govern("database.query", "production_db")
async def query_database(sql: str):
    return await db.execute(sql)

@mcp_server.tool()
@middleware.govern("file.read", "/data/reports")
async def read_report(path: str):
    return await fs.read(path)

Learn more: MCP Integration Guide

Feature Deep Dives

Smart Rules

Automatically generate policies from patterns:

Dashboard > Policies > Smart Rules > Enable

ASCEND analyzes action patterns and suggests policies:

• Frequently denied action patterns
• Common approval workflows
• Risk anomaly detection

A/B Testing

Test policy changes before deployment:

# Create A/B test
POST /api/ab-tests
{
    "name": "New Refund Policy Test",
    "control_policy": "pol_abc123",
    "test_policy": "pol_xyz789",
    "traffic_split": 10,  # 10% to test
    "duration_days": 7
}

Learn more: A/B Testing Guide

Approval Workflows

Configure multi-level approvals:

{
    "name": "High Value Transaction Workflow",
    "steps": [
        {
            "approvers": ["team-lead"],
            "required": 1,
            "timeout_hours": 4
        },
        {
            "approvers": ["finance-manager", "compliance-officer"],
            "required": 1,
            "timeout_hours": 24
        }
    ],
    "escalation": {
        "timeout_action": "escalate",
        "escalation_approvers": ["vp-finance"]
    }
}

Learn more: Approval Workflows Guide

Executive Dashboards

Generate executive briefings:

Dashboard > Analytics > Executive Brief > Generate

Includes:

• Security posture summary
• Risk trends
• Compliance status
• Agent activity highlights

Learn more: Executive Dashboard Guide

Code Examples

Python: Async Action Evaluation

import asyncio
from ascend import AscendClient

async def evaluate_batch_actions(client: AscendClient, actions: list):
    """Evaluate multiple actions concurrently."""
    tasks = [
        asyncio.create_task(
            asyncio.to_thread(
                client.evaluate_action,
                action_type=a["type"],
                resource=a["resource"],
                parameters=a["params"]
            )
        )
        for a in actions
    ]
    return await asyncio.gather(*tasks)

Node.js: Webhook Handler

import express from 'express';
import crypto from 'crypto';

const app = express();

app.post('/webhooks/ascend', express.raw({type: 'application/json'}), (req, res) => {
    const signature = req.headers['x-signature'];
    const timestamp = req.headers['x-request-timestamp'];
    const payload = req.body.toString();

    // Verify signature
    const expected = crypto
        .createHmac('sha256', process.env.WEBHOOK_SECRET)
        .update(`${timestamp}.${payload}`)
        .digest('hex');

    if (`v1=${expected}` !== signature) {
        return res.status(401).send('Invalid signature');
    }

    const event = JSON.parse(payload);

    switch (event.event) {
        case 'action.approved':
            handleApproval(event.data);
            break;
        case 'action.denied':
            handleDenial(event.data);
            break;
        case 'alert.triggered':
            handleAlert(event.data);
            break;
    }

    res.status(200).send('OK');
});

Terraform: Infrastructure Policy

# Governance for Terraform operations
resource "ascend_policy" "terraform_governance" {
    name        = "Terraform Production Changes"
    description = "Require approval for production infrastructure changes"

    conditions = jsonencode({
        "action_type": "infrastructure.apply",
        "context.environment": "production"
    })

    action      = "require_approval"
    approvers   = ["infra-lead", "sre-team"]
    priority    = 80
}

Best Practices Summary

Security

1. Use fail_mode=CLOSED in production - Block actions when ASCEND is unreachable
2. Rotate API keys regularly - Set up key rotation schedules
3. Enable MFA - Require MFA for all console users
4. Audit API key usage - Review API key logs weekly

Performance

1. Use connection pooling - Reuse SDK client instances
2. Enable caching - Configure appropriate cache TTLs
3. Batch evaluations - Group related actions when possible
4. Monitor latency - Track evaluation times in your APM

Operations

1. Start with monitoring mode - Flag instead of deny initially
2. Create clear escalation paths - Define who approves what
3. Set up alerts - Get notified of anomalies
4. Review policies quarterly - Adjust based on patterns

Troubleshooting Resources

Common issues and solutions:

Issue	Solution	Documentation
Connection timeouts	Check network and increase timeout	Troubleshooting
Rate limiting	Implement backoff or request increase	Rate Limits
Policy not matching	Verify conditions and priority	Policy Debugging
High latency	Enable caching, check batch size	Performance Tuning

Support Resources

Documentation

• This Site: Comprehensive documentation
• API Reference: OpenAPI specification at /api/docs
• SDK Reference: Language-specific guides

Community

• GitHub Discussions: Ask questions, share patterns
• Release Notes: Stay updated on new features

Enterprise Support

Enterprise customers have access to:

• 24/7 technical support
• Dedicated success manager
• Custom integration assistance
• SLA guarantees

Quick Reference Cards

Python SDK Quick Reference

from ascend import AscendClient, Decision, FailMode

# Initialize
client = AscendClient(api_key="...", agent_id="...", fail_mode=FailMode.CLOSED)

# Register
client.register(agent_type="supervised", capabilities=["data_access"])

# Evaluate
decision = client.evaluate_action(action_type="...", resource="...", parameters={})

# Check decision
if decision.decision == Decision.ALLOWED:
    # Execute
    client.log_action_completed(decision.action_id, result={})
elif decision.decision == Decision.PENDING:
    client.wait_for_decision(decision.action_id, timeout=300)
elif decision.decision == Decision.DENIED:
    # Handle denial
    pass

API Quick Reference

# Evaluate action
POST /api/authorization/agent-action
X-API-Key: your_key

# Get action status
GET /api/agent-action/status/{action_id}

# Log completion
POST /api/agent-action/{action_id}/complete

# Check approval
GET /api/sdk/approval/{approval_id}

Feedback

We want to hear from you:

• Documentation Issues: Report unclear or missing content
• Feature Requests: Suggest improvements
• Bug Reports: Report SDK or API issues

Contact: support@owkai.app

Next Steps Checklist

Before going to production, ensure you have:

• Configured fail mode appropriately
• Created policies for critical actions
• Set up approval workflows
• Configured alert notifications
• Tested in staging environment
• Reviewed security settings
• Trained team on console usage
• Set up monitoring and alerting

---

Last Updated: 2026-01-20