Skip to content

Enterprise Deployment

How to deploy the FCC Agent Team Framework in enterprise documentation pipelines, knowledge management systems, and team workflows.

Deployment Architecture

Single-Team Deployment

For a single team using FCC for documentation and workflows:

+------------------+     +------------------+     +------------------+
| Development Team |---->| FCC Framework    |---->| Generated Docs   |
| (Authors)        |     | (Local Install)  |     | (56 files/persona)|
+------------------+     +------------------+     +------------------+
                               |
                          +----+----+
                          | Event   |
                          | Bus     |
                          +---------+

Multi-Team Deployment

For organizations with multiple teams sharing a persona catalog:

+----------+     +------------------+     +------------------+
| Team A   |---->|                  |     |                  |
+----------+     |  FCC Framework   |---->|  Shared Persona  |
| Team B   |---->|  (Shared Server) |     |  Registry        |
+----------+     |                  |     |  (102+ personas) |
| Team C   |---->|                  |     |                  |
+----------+     +------------------+     +------------------+
                       |         |
                  +----+    +----+----+
                  | KG  |   | Federation|
                  +-----+   +----------+

Documentation Pipeline Setup

Step 1: Configure the Doc Generator

from fcc.scaffold.doc_generator import DocGenerator
from fcc.personas.registry import PersonaRegistry

registry = PersonaRegistry.from_package_data()
generator = DocGenerator(registry=registry)

# Generate for all personas
for persona in registry.all():
    docs = generator.generate_persona_docs(persona.id)
    for path, content in docs.items():
        output_path = f"generated-docs/{persona.category}/{persona.id}/{path}"
        # Write to file system or artifact store

Step 2: Integrate with Build System

Add FCC doc generation to your Makefile or build script:

.PHONY: docs
docs:
    fcc generate-docs --output-dir ./generated-docs
    fcc validate-docs --input-dir ./generated-docs
    fcc sitemap --output-dir ./generated-docs

Step 3: Set Up Quality Gates

Configure quality gates for your documentation pipeline:

from fcc.governance.quality_gates import QualityGateRegistry

gates = QualityGateRegistry.from_package_data()

# Check all gates for a deliverable
for gate in gates.all():
    result = gate.check(deliverable)
    if not result.passed:
        print(f"FAILED: {gate.name} -- {result.reason}")
        # Block deployment

Custom Persona Deployment

Adding Enterprise-Specific Personas

Create custom personas in YAML:

# personas/enterprise/compliance_officer.yaml
id: compliance_officer
name: Compliance Officer
category: enterprise
riscear:
  role: "Ensure all documentation meets regulatory requirements"
  input: "Documentation drafts, regulatory standards"
  style: "Formal, precise, citation-heavy"
  constraints: "Must reference specific regulations by code"
  expected_output: "Compliance report with pass/fail per section"
  archetype: "The Guardian"
  responsibilities:
    - "Review documentation against regulatory requirements"
    - "Flag non-compliant sections with specific citations"
    - "Provide remediation guidance"
  role_skills:
    - "Regulatory knowledge"
    - "Technical writing review"
    - "Risk assessment"
  role_collaborators:
    - id: "data_governance_steward"
      type: "coordination"
    - id: "governance_compliance_auditor"
      type: "handoff"
  role_adoption_checklist:
    - "Identify applicable regulations"
    - "Configure quality gates for each regulation"
    - "Set up audit trail via event bus"

Loading Custom Personas

from fcc.personas.registry import PersonaRegistry

# Load default + custom personas
registry = PersonaRegistry.from_package_data()
registry.load_directory("personas/enterprise/")

# Verify
custom = registry.get("compliance_officer")
print(f"Loaded: {custom.name}")

Scaling Considerations

Performance

Component Scalability Notes
Persona Registry In-memory, loads in <1s for 100+ personas
Simulation Engine Per-run; parallelizable across scenarios
Event Bus Thread-safe; consider async for high throughput
Knowledge Graph In-memory; export to graph DB for large graphs
RAG Pipeline Chunking is CPU-bound; retrieval is I/O-bound
Doc Generation Parallelizable per persona

High Availability

For production deployments requiring high availability:

  1. Use the Protocol layer (WebSocket/SSE) for distributed communication
  2. Export events to a persistent message queue
  3. Use JSON file exporters for observability data persistence
  4. Back knowledge graphs with a graph database

Security Considerations

  • Store API keys in environment variables, never in code
  • Use the governance layer to enforce data handling policies
  • Enable audit trails via event bus + session recording
  • Review constitution hard-stop rules for data sensitivity