Enterprise Decisions - ARTEMIS Agents
Author: Subhadip Mitra
Description: Adaptive Reasoning Through Evaluation of Multi-agent Intelligent Systems

Skip to content

# Enterprise Decisions

This example demonstrates using ARTEMIS for real-world enterprise decision-making scenarios.

## Technology Stack Decision

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_tech_stack_debate():
        # Enterprise jury with high consensus for technology decisions
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.7,
        )

        agents = [
            Agent(
                name="rust_advocate",
                role="Systems architect advocating for Rust adoption",
                model="gpt-4o",
            ),
            Agent(
                name="go_advocate",
                role="Platform engineer advocating for Go adoption",
                model="gpt-4o",
            ),
            Agent(
                name="python_advocate",
                role="Engineering lead advocating for Python optimization",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            We need to choose a primary language for our new microservices platform.
            Considerations:
            - Current team: 50 Python developers, 10 Go developers
            - Requirements: High performance, cloud-native, 5-year horizon
            - Scale: 10M daily active users, sub-100ms latency requirements
            """,
            agents=agents,
            rounds=3,
            jury=jury,
        )

        debate.assign_positions({
            "rust_advocate": """
            Advocates for Rust: Memory safety without GC, best-in-class performance,
            growing ecosystem, prevents entire classes of bugs. Worth the learning
            curve for long-term benefits. Companies like Discord, Cloudflare use it.
            """,
            "go_advocate": """
            Advocates for Go: Simple, fast compilation, excellent concurrency,
            proven at scale (Google, Uber, Dropbox). Easy hiring, quick onboarding.
            Cloud-native DNA. Good enough performance for most use cases.
            """,
            "python_advocate": """
            Advocates for Python with optimization: Team already knows it, massive
            ecosystem, use PyPy/Cython for hot paths, proven at Instagram scale.
            Minimize retraining, leverage existing expertise. Microservices allow
            targeted optimization.
            """,
        })

        result = await debate.run()

        print("TECHNOLOGY STACK DECISION")
        print("=" * 60)
        print(f"\nRecommendation: {result.verdict.decision}")
        print(f"Confidence: {result.verdict.confidence:.0%}")
        print(f"Unanimous: {result.verdict.unanimous}")

        if result.verdict.score_breakdown:
            print("\nAGENT SCORES:")
            for agent, score in result.verdict.score_breakdown.items():
                print(f"  {agent}: {score:.2f}")

        print(f"\nRATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_tech_stack_debate())

## Build vs Buy Decision

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_build_vs_buy_debate():
        # Executive-level jury for strategic decisions
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.7,
        )

        agents = [
            Agent(
                name="build",
                role="Engineering advocate for building in-house",
                model="gpt-4o",
            ),
            Agent(
                name="buy",
                role="Operations advocate for purchasing solution",
                model="gpt-4o",
            ),
            Agent(
                name="hybrid",
                role="Strategy advocate for hybrid approach",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            Should we build our own customer data platform (CDP) or buy an
            existing solution?

            Context:
            - Budget: $2M first year, $500K/year ongoing
            - Timeline: Need solution in 9 months
            - Team: 8 senior engineers available
            - Data volume: 50M customer profiles, 1B events/month
            - Current stack: AWS, Snowflake, dbt
            """,
            agents=agents,
            rounds=3,
            jury=jury,
        )

        debate.assign_positions({
            "build": """
            Advocates building in-house: Full control, no vendor lock-in,
            tailored to needs, builds internal capability, long-term cost
            savings. Can leverage existing Snowflake investment. IP ownership.
            """,
            "buy": """
            Advocates buying (Segment, mParticle, etc.): Faster time-to-market,
            proven at scale, ongoing innovation, focus on core business,
            predictable costs. Let experts handle infrastructure.
            """,
            "hybrid": """
            Advocates hybrid approach: Buy core CDP, build custom integrations
            and ML layer. Best of both worlds. Start with vendor, plan for
            strategic components in-house over time.
            """,
        })

        result = await debate.run()

        print("BUILD VS BUY DECISION: CDP")
        print("=" * 60)
        print(f"\nDecision: {result.verdict.decision}")
        print(f"Executive Confidence: {result.verdict.confidence:.0%}")

        if result.verdict.score_breakdown:
            print("\nAPPROACH SCORES:")
            for agent, score in result.verdict.score_breakdown.items():
                indicator = "BUILD" if "build" in agent else "BUY" if "buy" in agent else "HYBRID"
                print(f"  {indicator}: {score:.2f}")

        print(f"\nEXECUTIVE SUMMARY:\n{result.verdict.reasoning}")

    asyncio.run(run_build_vs_buy_debate())

## Vendor Selection

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_vendor_selection_debate():
        # Procurement-focused jury
        jury = JuryPanel(
            evaluators=3,
            model="gpt-4o",
            consensus_threshold=0.7,
        )

        agents = [
            Agent(
                name="vendor_a",
                role="Advocate for Datadog platform",
                model="gpt-4o",
            ),
            Agent(
                name="vendor_b",
                role="Advocate for New Relic platform",
                model="gpt-4o",
            ),
            Agent(
                name="vendor_c",
                role="Advocate for Grafana Cloud platform",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            Select a cloud observability platform for our infrastructure.

            Requirements:
            - APM, logs, metrics, and traces unified
            - Support for Kubernetes and serverless
            - 500+ services, 10TB logs/day
            - Budget: $300K/year
            - Current: Self-hosted ELK + Prometheus (pain points: scale, correlation)

            Finalists: Datadog, New Relic, Grafana Cloud
            """,
            agents=agents,
            rounds=2,
            jury=jury,
        )

        debate.assign_positions({
            "vendor_a": """
            Advocates for Datadog: Market leader, best-in-class UX, unified platform,
            strong APM. Higher cost but comprehensive. Used by similar companies.
            ML-powered insights. Excellent K8s support.
            """,
            "vendor_b": """
            Advocates for New Relic: Competitive pricing (consumption-based),
            strong APM heritage, recent platform improvements. Good value for
            budget. Full-stack observability. Entity-centric model.
            """,
            "vendor_c": """
            Advocates for Grafana Cloud: Best value, open-source foundation,
            no vendor lock-in (LGTM stack), team familiarity with Grafana.
            Flexible pricing. Strong community. Pairs with existing Prometheus.
            """,
        })

        result = await debate.run()

        print("VENDOR SELECTION: OBSERVABILITY PLATFORM")
        print("=" * 60)
        print(f"\nSelected Vendor: {result.verdict.decision}")
        print(f"Selection Confidence: {result.verdict.confidence:.0%}")

        if result.verdict.score_breakdown:
            print("\nEVALUATION SCORES:")
            for agent, score in result.verdict.score_breakdown.items():
                print(f"  {agent}: {score:.2f}")

        print(f"\nSELECTION RATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_vendor_selection_debate())

## Organizational Restructuring

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel
    from artemis.safety import MonitorMode, EthicsGuard, EthicsConfig

    async def run_reorg_debate():
        # Ethics guard for sensitive HR decisions
        ethics_config = EthicsConfig(
            harmful_content_threshold=0.5,
            bias_threshold=0.4,
            fairness_threshold=0.4,
            enabled_checks=["harmful_content", "bias", "fairness"],
        )

        ethics_guard = EthicsGuard(
            mode=MonitorMode.PASSIVE,
            config=ethics_config,
        )

        # Leadership jury
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.7,
        )

        agents = [
            Agent(
                name="consolidation",
                role="COO advocating for team consolidation",
                model="gpt-4o",
            ),
            Agent(
                name="expansion",
                role="CPO advocating for team expansion",
                model="gpt-4o",
            ),
            Agent(
                name="transformation",
                role="CTO advocating for platform team model",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            How should we restructure our engineering organization?

            Current state:
            - 400 engineers across 12 product teams
            - Siloed teams, duplicate efforts
            - Slow cross-team coordination
            - 30% growth planned next year

            Options: Consolidate, Expand, or Transform to platform model
            """,
            agents=agents,
            rounds=2,
            jury=jury,
            safety_monitors=[ethics_guard.process],
        )

        debate.assign_positions({
            "consolidation": """
            Advocates for consolidation: Merge similar teams, reduce management
            layers, create shared services. Eliminate duplication. More efficient
            use of resources. Clear ownership. May involve some reduction.
            """,
            "expansion": """
            Advocates for expansion: Add new teams for growth areas, hire team
            leads, maintain team autonomy. Support growth plans. Preserve culture.
            Address coordination through better tooling, not restructuring.
            """,
            "transformation": """
            Advocates for platform transformation: Create platform teams that
            serve product teams. Shift to internal platform model. Balance
            autonomy with shared infrastructure. Requires cultural shift.
            """,
        })

        result = await debate.run()

        print("ORGANIZATIONAL RESTRUCTURING DECISION")
        print("=" * 60)

        if result.safety_alerts:
            print("\nETHICS CONSIDERATIONS:")
            for alert in result.safety_alerts:
                print(f"  - {alert.type}: severity {alert.severity:.2f}")

        print(f"\nDecision: {result.verdict.decision}")
        print(f"Leadership Alignment: {result.verdict.confidence:.0%}")
        print(f"\nRATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_reorg_debate())

## M&A Due Diligence

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_ma_debate():
        # Executive committee jury for major decisions
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.75,  # High bar for M&A
        )

        agents = [
            Agent(
                name="bull_case",
                role="M&A advocate presenting acquisition thesis",
                model="gpt-4o",
            ),
            Agent(
                name="bear_case",
                role="Risk analyst presenting concerns",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            Should we acquire TargetCo, an AI startup, at $200M valuation?

            TargetCo profile:
            - ARR: $15M, growing 100% YoY
            - Team: 45 engineers, strong AI talent
            - Product: AI copilot for developers
            - Tech: Proprietary models, unique dataset
            - Competition: GitHub Copilot, Amazon CodeWhisperer

            Our situation:
            - We need AI capabilities
            - Organic build would take 2 years
            - Strategic importance: high
            - Cash position: $500M
            """,
            agents=agents,
            rounds=3,
            jury=jury,
        )

        debate.assign_positions({
            "bull_case": """
            Argues FOR acquisition: Strategic necessity, talent acquisition,
            time-to-market advantage, reasonable valuation at 13x ARR for
            high-growth AI company. Competitive moat. Synergies with our
            developer tools. Key hires are committed.
            """,
            "bear_case": """
            Argues AGAINST or for lower valuation: Execution risk, integration
            challenges, key person risk, competitive pressure from Big Tech,
            valuation stretched. Could build for less. Retention uncertainty.
            AI market evolving rapidly.
            """,
        })

        result = await debate.run()

        print("M&A DUE DILIGENCE: TARGETCO ACQUISITION")
        print("=" * 60)
        print(f"\nRecommendation: {result.verdict.decision}")
        print(f"Board Confidence: {result.verdict.confidence:.0%}")
        print(f"Unanimous: {result.verdict.unanimous}")

        if result.verdict.score_breakdown:
            print("\nARGUMENT STRENGTH:")
            for agent, score in result.verdict.score_breakdown.items():
                position = "PROCEED" if "bull" in agent else "CAUTION"
                print(f"  {position}: {score:.2f}")

        print(f"\nINVESTMENT THESIS:\n{result.verdict.reasoning}")

        # Show dissenting opinions if any
        if result.verdict.dissenting_opinions:
            print("\nDISSENTING VIEWS:")
            for dissent in result.verdict.dissenting_opinions:
                print(f"  {dissent.perspective.value}: {dissent.reasoning[:150]}...")

    asyncio.run(run_ma_debate())

## Pricing Strategy

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_pricing_debate():
        # Revenue and marketing jury
        jury = JuryPanel(
            evaluators=3,
            model="gpt-4o",
            consensus_threshold=0.6,
        )

        agents = [
            Agent(
                name="premium",
                role="Chief Revenue Officer advocating premium pricing",
                model="gpt-4o",
            ),
            Agent(
                name="competitive",
                role="CMO advocating competitive pricing for market share",
                model="gpt-4o",
            ),
            Agent(
                name="value_based",
                role="VP Strategy advocating value-based pricing",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            How should we price our new enterprise AI product?

            Context:
            - Product: AI-powered analytics platform
            - Cost to serve: ~$2K/month per customer
            - Competitors: $5K-15K/month
            - Our brand: Premium, trusted
            - Value delivered: ~$50K/month savings for typical customer
            - Market: Growing 40% YoY
            """,
            agents=agents,
            rounds=2,
            jury=jury,
        )

        debate.assign_positions({
            "premium": """
            Advocates premium pricing ($12-15K/month): Our brand commands
            premium, value justifies price, attracts serious buyers, better
            margins fund R&D. Price signals quality. Enterprise buyers expect
            to pay for value.
            """,
            "competitive": """
            Advocates competitive pricing ($6-8K/month): Win market share in
            growing market, land-and-expand model, volume matters for AI
            training data. Lower barrier to adoption. Can raise prices later.
            """,
            "value_based": """
            Advocates value-based pricing (% of savings): Align with customer
            outcomes, usage-based component, reduces friction, scales with
            customer success. Novel approach differentiates us.
            """,
        })

        result = await debate.run()

        print("PRICING STRATEGY DECISION")
        print("=" * 60)
        print(f"\nRecommended Strategy: {result.verdict.decision}")
        print(f"Alignment: {result.verdict.confidence:.0%}")

        if result.verdict.score_breakdown:
            print("\nSTRATEGY SCORES:")
            for agent, score in result.verdict.score_breakdown.items():
                print(f"  {agent}: {score:.2f}")

        print(f"\nSTRATEGIC RATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_pricing_debate())

## Cloud Migration Strategy

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_cloud_migration_debate():
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.7,
        )

        agents = [
            Agent(
                name="lift_shift",
                role="Infrastructure lead advocating lift-and-shift",
                model="gpt-4o",
            ),
            Agent(
                name="re_architect",
                role="Architect advocating cloud-native re-architecture",
                model="gpt-4o",
            ),
            Agent(
                name="hybrid",
                role="CTO advocating phased hybrid approach",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            How should we migrate our on-premise infrastructure to cloud?

            Current state:
            - 200 VMs running legacy applications
            - 50 databases (Oracle, SQL Server, PostgreSQL)
            - $3M/year data center costs
            - 18-month lease remaining

            Options: Lift-and-shift, Re-architect, or Phased hybrid
            """,
            agents=agents,
            rounds=2,
            jury=jury,
        )

        debate.assign_positions({
            "lift_shift": """
            Advocates lift-and-shift: Fastest path to cloud, lowest risk,
            preserve existing investments, train team on cloud gradually.
            Optimize later. Meet lease deadline. Predictable costs.
            """,
            "re_architect": """
            Advocates re-architecture: Build cloud-native, leverage managed
            services, reduce operational burden, future-proof architecture.
            Higher upfront cost but better long-term. Modernize tech debt.
            """,
            "hybrid": """
            Advocates phased approach: Start with lift-and-shift for non-critical,
            re-architect critical apps, keep some on-prem for compliance.
            Balance speed with optimization. Reduce risk through phases.
            """,
        })

        result = await debate.run()

        print("CLOUD MIGRATION STRATEGY")
        print("=" * 60)
        print(f"\nRecommended Approach: {result.verdict.decision}")
        print(f"Confidence: {result.verdict.confidence:.0%}")

        if result.verdict.score_breakdown:
            print("\nAPPROACH ANALYSIS:")
            for agent, score in result.verdict.score_breakdown.items():
                print(f"  {agent}: {score:.2f}")

        print(f"\nMIGRATION RATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_cloud_migration_debate())

## Security Investment Prioritization

    import asyncio
    from artemis.core.agent import Agent
    from artemis.core.debate import Debate
    from artemis.core.jury import JuryPanel

    async def run_security_debate():
        jury = JuryPanel(
            evaluators=5,
            model="gpt-4o",
            consensus_threshold=0.75,  # High bar for security
        )

        agents = [
            Agent(
                name="zero_trust",
                role="Security architect advocating zero trust",
                model="gpt-4o",
            ),
            Agent(
                name="detection",
                role="SOC lead advocating detection and response",
                model="gpt-4o",
            ),
            Agent(
                name="compliance",
                role="GRC lead advocating compliance-first",
                model="gpt-4o",
            ),
        ]

        debate = Debate(
            topic="""
            Where should we invest our $2M security budget?

            Current state:
            - Basic perimeter security
            - No SOC, reactive incident response
            - SOC2 certification needed in 6 months
            - Recent phishing incidents

            Options: Zero trust architecture, Detection/Response, Compliance-first
            """,
            agents=agents,
            rounds=2,
            jury=jury,
        )

        debate.assign_positions({
            "zero_trust": """
            Advocates zero trust: Prevent breaches at source, identity-centric
            security, microsegmentation. Long-term protection. Industry direction.
            Reduces blast radius. Works for remote workforce.
            """,
            "detection": """
            Advocates detection/response: Build SOC capability, SIEM/SOAR,
            threat hunting. Can't prevent everything, need to detect and respond.
            Faster time to value. Address immediate risks.
            """,
            "compliance": """
            Advocates compliance-first: SOC2 is blocking sales. Address
            compliance gap first, then build security. Frameworks provide
            good baseline. Certification enables growth.
            """,
        })

        result = await debate.run()

        print("SECURITY INVESTMENT DECISION")
        print("=" * 60)
        print(f"\nPriority: {result.verdict.decision}")
        print(f"Confidence: {result.verdict.confidence:.0%}")

        if result.verdict.score_breakdown:
            print("\nINVESTMENT ANALYSIS:")
            for agent, score in result.verdict.score_breakdown.items():
                print(f"  {agent}: {score:.2f}")

        print(f"\nSECURITY RATIONALE:\n{result.verdict.reasoning}")

    asyncio.run(run_security_debate())

## Next Steps

- See Multi-Agent Debates for stakeholder modeling
- Create Custom Juries for your domain
- Explore Ethical Dilemmas for sensitive decisions