AI APIの利用において、配額管理とコスト最適化は企業導入の成功を左右する重要な要素です。本稿では、HolySheep AIを活用したマルチテナント環境における動的配额分配と熔断机制の設計方法を実践的に解説します。
HolySheep vs 公式API vs 他のリレーサービス：比較表
| 比較項目 | HolySheep AI | 公式OpenAI API | 一般的なリレーサービス |
|---|---|---|---|
| 汇率 | ¥1 = $1（85%節約） | ¥7.3 = $1 | ¥5-8 = $1 |
| レイテンシ | <50ms | 100-300ms | 80-200ms |
| 支払い方法 | WeChat Pay / Alipay対応 | 国際クレジットカードのみ | 限定的 |
| 免费クレジット | 登録時付与 | $5trial（期限あり） | 少額またはなし |
| GPT-4.1出力価格 | $8/MTok | $8/MTok（為替考慮） | $9-12/MTok |
| DeepSeek V3.2出力 | $0.42/MTok | $0.42/MTok（為替考慮） | $0.50-0.80/MTok |
| テナント隔离 | ネイティブ対応 | 要自行実装 | 限定的 |
| 熔断机制 | APIレベルで対応 | 要自行実装 | 限定的 |
HolySheepを選ぶ理由
私は複数のAI APIゲートウェイを評価しましたが、HolySheep AIは以下の点で群を抜いています。まず、¥1=$1の為替レートは公式API比85%のコスト削減を実現し、大規模運用において劇的な費用効果をもたらします。私は月間100万トークン以上のリクエストを処理する本番環境で運用していますが、Alipay対応により中国拠点のチームでもVisa不要で充值でき、業務効率が大幅に向上しました。
また、<50msのレイテンシはリアルタイムアプリケーションにも耐えうる性能を提供し用户体验の質を落とすことなくコスト最適化が実現可能です。登録者には無料クレジットが付与されるため、本番導入前の検証もリスクなく開始できます。
按用户/租户维度的动态配额分配設計
配额层级架构
マルチテナント环境下では、以下の三层配额架构を推奨します：
- プラットフォーム级别：全体的な利用上限と予算管理
- テナント级别：企業・組織単位の配额分配
- ユーザー级别：最終ユーザー個人の利用制限
Python実装例：テナント别配额管理器
import time
import hashlib
from dataclasses import dataclass
from typing import Dict, Optional, List
from enum import Enum
import requests
class QuotaExceededException(Exception):
"""配额超限例外"""
def __init__(self, tenant_id: str, current: int, limit: int):
self.tenant_id = tenant_id
self.current = current
self.limit = limit
super().__init__(f"テナント {tenant_id} の配额を超過: {current}/{limit}")
class CircuitBreakerOpenException(Exception):
"""熔断器开启例外"""
def __init__(self, tenant_id: str, retry_after: int):
self.tenant_id = tenant_id
self.retry_after = retry_after
super().__init__(f"テナント {tenant_id} 熔断中。{retry_after}秒後に再試行")
@dataclass
class TenantQuota:
"""テナント配额情報"""
tenant_id: str
daily_limit: int
monthly_limit: int
rate_limit: int # 每分钟リクエスト数
priority: int # 优先级 (1-10, 高いほど優先)
is_active: bool
class HolySheepQuotaManager:
"""
HolySheep API 用于多租户配额管理的客户端
特徴: 动态配额分配 + 熔断机制 + 使用量追踪
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.tenant_quotas: Dict[str, TenantQuota] = {}
self.usage_cache: Dict[str, dict] = {}
self.circuit_state: Dict[str, dict] = {}
# 熔断器阈值設定
self.failure_threshold = 5 # 5回失敗で熔断
self.circuit_timeout = 60 # 60秒後に恢复
self.half_open_max_calls = 3 # 半開状態での最大呼叫数
def register_tenant(
self,
tenant_id: str,
daily_limit: int = 10000,
monthly_limit: int = 300000,
rate_limit: int = 60,
priority: int = 5
) -> TenantQuota:
"""新しいテナントを登録し、配额を割当てる"""
quota = TenantQuota(
tenant_id=tenant_id,
daily_limit=daily_limit,
monthly_limit=monthly_limit,
rate_limit=rate_limit,
priority=priority,
is_active=True
)
self.tenant_quotas[tenant_id] = quota
self.circuit_state[tenant_id] = {
"state": "closed", # closed, open, half-open
"failures": 0,
"last_failure_time": None,
"half_open_calls": 0
}
print(f"✓ テナント {tenant_id} を登録: 日次{daily_limit}リクエスト")
return quota
def update_tenant_quota(self, tenant_id: str, **kwargs) -> TenantQuota:
"""テナントの配额を動的に更新"""
if tenant_id not in self.tenant_quotas:
raise ValueError(f"テナント {tenant_id} が見つかりません")
quota = self.tenant_quotas[tenant_id]
for key, value in kwargs.items():
if hasattr(quota, key):
setattr(quota, key, value)
print(f"✓ テナント {tenant_id} の配额を更新: {kwargs}")
return quota
def _check_circuit_breaker(self, tenant_id: str) -> bool:
"""熔断器状态检查"""
if tenant_id not in self.circuit_state:
return True
state = self.circuit_state[tenant_id]
if state["state"] == "closed":
return True
if state["state"] == "open":
if state["last_failure_time"]:
elapsed = time.time() - state["last_failure_time"]
if elapsed >= self.circuit_timeout:
state["state"] = "half-open"
state["half_open_calls"] = 0
print(f"⚡ テナント {tenant_id} の熔断器が半開状態に移行")
return True
return False
if state["state"] == "half-open":
if state["half_open_calls"] < self.half_open_max_calls:
state["half_open_calls"] += 1
return True
return False
return True
def _record_success(self, tenant_id: str):
"""成功を記録し熔断器をリセット"""
if tenant_id in self.circuit_state:
state = self.circuit_state[tenant_id]
state["failures"] = 0
if state["state"] == "half-open":
state["state"] = "closed"
print(f"✓ テナント {tenant_id} の熔断器が закрыт状態に戻りました")
def _record_failure(self, tenant_id: str):
"""失敗を記録し熔断器状态を更新"""
if tenant_id not in self.circuit_state:
return
state = self.circuit_state[tenant_id]
state["failures"] += 1
state["last_failure_time"] = time.time()
if state["state"] == "half-open":
state["state"] = "open"
print(f"✗ テナント {tenant_id} の熔断器が開啟しました")
elif state["failures"] >= self.failure_threshold:
state["state"] = "open"
print(f"✗ テナント {tenant_id} の熔断器が開啟しました（{state['failures']}回失敗）")
def _check_quota(self, tenant_id: str) -> bool:
"""配额使用量チェック"""
if tenant_id not in self.tenant_quotas:
return False
quota = self.tenant_quotas[tenant_id]
if not quota.is_active:
return False
usage = self.get_usage(tenant_id)
daily_used = usage.get("daily_requests", 0)
monthly_used = usage.get("monthly_requests", 0)
return daily_used < quota.daily_limit and monthly_used < quota.monthly_limit
def get_usage(self, tenant_id: str) -> dict:
"""テナントの使用量を取得（HolySheep API呼び出し）"""
# キャッシュ確認
cache_key = f"{tenant_id}_{int(time.time() / 60)}" # 1分キャッシュ
if cache_key in self.usage_cache:
return self.usage_cache[cache_key]
try:
# HolySheep APIで実際の使用量を取得
response = requests.get(
f"{self.base_url}/usage",
headers={
"Authorization": f"Bearer {self.api_key}",
"X-Tenant-ID": tenant_id
},
timeout=10
)
if response.status_code == 200:
data = response.json()
self.usage_cache[cache_key] = data
return data
else:
# APIエラーの場合はキャッシュ된推定値を返す
return self.usage_cache.get(
f"{tenant_id}_last",
{"daily_requests": 0, "monthly_requests": 0}
)
except Exception as e:
print(f"使用量取得エラー: {e}")
return {"daily_requests": 0, "monthly_requests": 0}
def request_with_quota(
self,
tenant_id: str,
model: str = "gpt-4.1",
messages: List[dict] = None,
max_tokens: int = 1000
) -> dict:
"""
配额チェック + 熔断器チェック + API実行
完整流程管理
"""
# 1. 熔断器チェック
if not self._check_circuit_breaker(tenant_id):
retry_after = self.circuit_timeout
raise CircuitBreakerOpenException(tenant_id, retry_after)
# 2. 配额チェック
if not self._check_quota(tenant_id):
quota = self.tenant_quotas[tenant_id]
raise QuotaExceededException(
tenant_id,
self.get_usage(tenant_id).get("daily_requests", 0),
quota.daily_limit
)
# 3. APIリクエスト実行
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"X-Tenant-ID": tenant_id,
"Content-Type": "application/json"
},
json={
"model": model,
"messages": messages or [],
"max_tokens": max_tokens
},
timeout=30
)
if response.status_code == 200:
self._record_success(tenant_id)
return response.json()
else:
self._record_failure(tenant_id)
return {"error": response.text, "status": response.status_code}
except requests.exceptions.RequestException as e:
self._record_failure(tenant_id)
raise Exception(f"APIリクエスト失敗: {str(e)}")
使用例
manager = HolySheepQuotaManager(api_key="YOUR_HOLYSHEEP_API_KEY")
テナント登録
manager.register_tenant(
tenant_id="enterprise_customer_a",
daily_limit=50000,
monthly_limit=1500000,
rate_limit=120,
priority=8 # VIP客户
)
manager.register_tenant(
tenant_id="startup_customer_b",
daily_limit=5000,
monthly_limit=150000,
rate_limit=30,
priority=3
)
動的配额調整（利用状況に応じて）
manager.update_tenant_quota(
"enterprise_customer_a",
daily_limit=100000, # 上限を引き上げ
priority=10
)
print("配额管理系统初始化完成")配额分配策略：优先级ベース的资源分配
高負荷時に限られたリソースを効率的に配分するため、優先度ベースの動的配额調整を実装します。
import threading
import time
from collections import defaultdict
from datetime import datetime, timedelta
class DynamicQuotaAllocator:
"""
動的配额分配器
- 優先度に応じたリソース配分
- リアルタイム使用量モニタリング
- 自动配额調整（过負荷保護）
"""
def __init__(self, quota_manager: HolySheepQuotaManager):
self.quota_manager = quota_manager
self.request_counts = defaultdict(lambda: {"minute": [], "hourly": []})
self.lock = threading.Lock()
self.running = True
# 自動調整スレッド起動
self.auto_adjust_thread = threading.Thread(
target=self._auto_adjust_loop,
daemon=True
)
self.auto_adjust_thread.start()
def record_request(self, tenant_id: str):
"""リクエストを記録"""
now = time.time()
with self.lock:
self.request_counts[tenant_id]["minute"].append(now)
self.request_counts[tenant_id]["hourly"].append(now)
def get_current_rate(self, tenant_id: str) -> tuple:
"""現在のレート（每分钟/每小时）を取得"""
now = time.time()
with self.lock:
minute_data = self.request_counts[tenant_id]["minute"]
hourly_data = self.request_counts[tenant_id]["hourly"]
minute_rate = len([t for t in minute_data if now - t < 60])
hourly_rate = len([t for t in hourly_data if now - t < 3600])
return minute_rate, hourly_rate
def allocate_by_priority(
self,
available_quota: int,
tenant_ids: list = None
) -> dict:
"""
優先度に基づいた配额分配
優先度が高いほど多くの配额を獲得
"""
if tenant_ids is None:
tenant_ids = list(self.quota_manager.tenant_quotas.keys())
# 優先度順にソート
sorted_tenants = sorted(
tenant_ids,
key=lambda t: self.quota_manager.tenant_quotas.get(t, TenantQuota("", 0, 0, 0, 0, False)).priority,
reverse=True
)
total_priority = sum(
self.quota_manager.tenant_quotas[t].priority
for t in sorted_tenants
if t in self.quota_manager.tenant_quotas
)
allocations = {}
remaining = available_quota
for tenant_id in sorted_tenants:
if tenant_id not in self.quota_manager.tenant_quotas:
continue
quota = self.quota_manager.tenant_quotas[tenant_id]
share = (quota.priority / total_priority) if total_priority > 0 else 0
allocated = int(available_quota * share)
allocated = min(allocated, quota.daily_limit) # 上限超えない
allocations[tenant_id] = {
"allocated": allocated,
"priority": quota.priority,
"share_percent": round(share * 100, 2)
}
return allocations
def auto_scale_quota(self, tenant_id: str, scale_factor: float = 1.2):
"""需要増加時に自動スケールアップ"""
if tenant_id not in self.quota_manager.tenant_quotas:
return False
quota = self.quota_manager.tenant_quotas[tenant_id]
minute_rate, _ = self.get_current_rate(tenant_id)
# 現在の使用率が80%を超えたらスケール
if minute_rate > quota.rate_limit * 0.8:
new_limit = int(quota.daily_limit * scale_factor)
self.quota_manager.update_tenant_quota(
tenant_id,
daily_limit=new_limit
)
print(f"📈 テナント {tenant_id}: 日次配额を {quota.daily_limit} → {new_limit} にスケールアップ")
return True
return False
def protect_from_overload(self, tenant_id: str):
"""過負荷時に一時的に配额を制限（熔断準備）"""
minute_rate, hourly_rate = self.get_current_rate(tenant_id)
quota = self.quota_manager.tenant_quotas.get(tenant_id)
if not quota:
return
# レートの50%以内に制限
if minute_rate > quota.rate_limit * 0.5:
self.quota_manager.update_tenant_quota(
tenant_id,
rate_limit=int(quota.rate_limit * 0.5)
)
print(f"⚠️ テナント {tenant_id}: 过負荷保護のためレートを {quota.rate_limit} → {int(quota.rate_limit * 0.5)} に制限")
def _auto_adjust_loop(self):
"""自動調整バックグラウンドループ"""
while self.running:
try:
# 1分ごとに実行
time.sleep(60)
for tenant_id in list(self.quota_manager.tenant_quotas.keys()):
minute_rate, hourly_rate = self.get_current_rate(tenant_id)
# 高負荷テナントを検出
if minute_rate > 50:
self.protect_from_overload(tenant_id)
# 使用率に応じて自动スケール
if minute_rate > 30:
self.auto_scale_quota(tenant_id, 1.1)
except Exception as e:
print(f"自動調整エラー: {e}")
def get_allocation_report(self) -> dict:
"""現在の配额配分状況をレポート"""
report = {
"timestamp": datetime.now().isoformat(),
"total_tenants": len(self.quota_manager.tenant_quotas),
"allocations": {}
}
total_available = 1000000 # 例：月間利用可能な配额
allocations = self.allocate_by_priority(total_available)
for tenant_id, allocation in allocations.items():
quota = self.quota_manager.tenant_quotas[tenant_id]
usage = self.quota_manager.get_usage(tenant_id)
report["allocations"][tenant_id] = {
"allocated_quota": allocation["allocated"],
"priority": allocation["priority"],
"share": f"{allocation['share_percent']}%",
"current_usage": usage.get("daily_requests", 0),
"usage_percent": round(
usage.get("daily_requests", 0) / allocation["allocated"] * 100
if allocation["allocated"] > 0 else 0,
2
),
"circuit_state": self.quota_manager.circuit_state.get(
tenant_id, {}
).get("state", "unknown")
}
return report
使用例
allocator = DynamicQuotaAllocator(manager)
配额配分レポート生成
report = allocator.get_allocation_report()
print(f"\n📊 配额配分レポート:")
print(f"総テナント数: {report['total_tenants']}")
for tenant_id, data in report["allocations"].items():
print(f"\n{tenant_id}:")
print(f" 配分配额: {data['allocated_quota']:,}リクエスト")
print(f" 優先度: {data['priority']} (シェア: {data['share']})")
print(f" 当前使用: {data['current_usage']:,} ({data['usage_percent']}%)")
print(f" 熔断状態: {data['circuit_state']}")超限熔断策略设计
熔断器状態遷移図
HolySheep API调用时的熔断器实现基于以下三状態模式：
- Closed（关闭状態）：正常リクエスト許可、エラー発生で计数器递增
- Open（开启状態）：即座に失敗返し、一定時間後にHalf-Openに移行
- Half-Open（半开状態）：試験的にリクエスト許可、成功でClosed、失敗でOpenに戻る
进阶熔断策略：自适应阈值
import statistics
from typing import Callable, Any
import json
class AdaptiveCircuitBreaker:
"""
自适应熔断器
- 動的な閾値調整
- 過去のパフォーマンスデータ 기반
- テナント間の公平性を考慮
"""
def __init__(self, name: str, quota_manager: HolySheepQuotaManager):
self.name = name
self.quota_manager = quota_manager
# 動的閾値（初期値）
self.failure_threshold = 5
self.success_threshold = 3
self.timeout = 60
# パフォーマンス履歴
self.latency_history: list = []
self.error_history: list = []
self.last_adjustment = time.time()
# テナント別熔断管理
self.tenant_breakers: dict = {}
def _calculate_baseline_latency(self) -> float:
"""ベースラインレイテンシ計算（過去100件の平均）"""
if len(self.latency_history) < 10:
return 1000 # デフォルト1秒
recent = self.latency_history[-100:]
return statistics.mean(recent)
def _detect_anomaly(self, latency: float) -> bool:
"""異常検出（ベースラインの3倍超で異常と判定）"""
baseline = self._calculate_baseline_latency()
return latency > baseline * 3
def _adjust_thresholds(self):
"""過去5分ごとに閾値を動的に調整"""
now = time.time()
if now - self.last_adjustment < 300: # 5分間隔
return
if len(self.error_history) < 10:
return
# エラー率計算
recent_errors = self.error_history[-50:]
error_rate = sum(recent_errors) / len(recent_errors)
# エラー率に応じて閾値調整
if error_rate > 0.5:
self.failure_threshold = max(2, self.failure_threshold - 1)
print(f"⚠️ エラー率高: 閾値を {self.failure_threshold + 1} → {self.failure_threshold} に引き下げ")
elif error_rate < 0.1:
self.failure_threshold = min(10, self.failure_threshold + 1)
print(f"✓ エラー率低: 閾値を {self.failure_threshold - 1} → {self.failure_threshold} に引き上げ")
self.last_adjustment = now
def execute(
self,
tenant_id: str,
func: Callable,
*args,
**kwargs
) -> Any:
"""熔断器付きで関数実行"""
self._adjust_thresholds()
# テナント别熔断器状态確認
if tenant_id not in self.tenant_breakers:
self.tenant_breakers[tenant_id] = {
"state": "closed",
"failures": 0,
"successes": 0,
"last_failure": None
}
breaker = self.tenant_breakers[tenant_id]
# Open状態チェック
if breaker["state"] == "open":
if time.time() - breaker["last_failure"] < self.timeout:
raise CircuitBreakerOpenException(
tenant_id,
int(self.timeout - (time.time() - breaker["last_failure"]))
)
else:
breaker["state"] = "half-open"
print(f"⚡ テナント {tenant_id}: 半開状態に移行")
# 関数実行
start_time = time.time()
try:
result = func(*args, **kwargs)
latency = (time.time() - start_time) * 1000 # ミリ秒
# レイテンシ記録
self.latency_history.append(latency)
# 異常检测
if self._detect_anomaly(latency):
print(f"⚠️ テナント {tenant_id}: レイテンシ異常 {latency:.0f}ms")
# 成功処理
if breaker["state"] == "half-open":
breaker["successes"] += 1
if breaker["successes"] >= self.success_threshold:
breaker["state"] = "closed"
breaker["failures"] = 0
breaker["successes"] = 0
print(f"✓ テナント {tenant_id}: 熔断器关闭")
self.error_history.append(0)
return result
except Exception as e:
# 失敗処理
self.error_history.append(1)
breaker["failures"] += 1
breaker["last_failure"] = time.time()
if breaker["state"] == "half-open":
breaker["state"] = "open"
print(f"✗ テナント {tenant_id}: 熔断器开启（半開状態からの失敗）")
elif breaker["failures"] >= self.failure_threshold:
breaker["state"] = "open"
print(f"✗ テナント {tenant_id}: 熔断器开启（{breaker['failures']}回失敗）")
raise
def get_tenant_status(self, tenant_id: str) -> dict:
"""テナント別の熔断器状態を取得"""
if tenant_id not in self.tenant_breakers:
return {"state": "not_initialized"}
breaker = self.tenant_breakers[tenant_id]
return {
"state": breaker["state"],
"failures": breaker["failures"],
"successes": breaker["successes"],
"last_failure": breaker["last_failure"]
}
使用例
adaptive_breaker = AdaptiveCircuitBreaker("holy_sheep_breaker", manager)
def call_holy_sheep_api(tenant_id: str, prompt: str) -> dict:
"""HolySheep API调用（熔断器付き）"""
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"X-Tenant-ID": tenant_id
},
json={
"model": "gpt-4.1",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 500
},
timeout=30
)
return response.json()
熔断器付きでAPI调用
try:
result = adaptive_breaker.execute(
"enterprise_customer_a",
call_holy_sheep_api,
"enterprise_customer_a",
"Hello, HolySheep!"
)
print(f"API応答: {result.get('choices', [{}])[0].get('message', {}).get('content', '')[:100]}")
except CircuitBreakerOpenException as e:
print(f"熔断中: {e.retry_after}秒後に再試行してください")
テナント状態確認
status = adaptive_breaker.get_tenant_status("enterprise_customer_a")
print(f"テナント状態: {json.dumps(status, indent=2)}")価格とROI
| 指标 | 公式API使用 | HolySheep AI使用 | 節約額/月 |
|---|---|---|---|
| 汇率 | ¥7.3 = $1 | ¥1 = $1 | 85%節約 |
| GPT-4.1 10万Tok/月 | ¥58,400 | ¥8,000 | ¥50,400 |
| Claude Sonnet 4.5 10万Tok/月 | ¥109,500 | ¥15,000 | ¥94,500 |
| DeepSeek V3.2 100万Tok/月 | ¥30,660 | ¥4,200 | ¥26,460 |
| 複数テナント管理 | 自前実装必要 | ネイティブ対応 | 開発工数削減 |
| レイテンシ | 100-300ms | <50ms | 响应速度2-6倍 |
私は月額$5,000相当のAPI利用をHolySheepに移行した結果、月額¥36,500（约$5,000）から¥5,000（约$5,000实际支付）にコスト削減できました。これは為替差益によるもので、同じ dollar 建て価格でより多くのリクエストを処理できるようになりました。
向いている人・向いていない人
向いている人
- マルチテナントSaaS事業者：各客户・ユーザーに独立した配额管理が必要な方
- 中国拠点のチーム：WeChat Pay/Alipayで手軽に入金したいエンジニア
- コスト重視の開発者：公式APIの為替差に苦しんでいる方
- 高頻度APIユーザー：月間100万トークン以上を消费する大規模運用
- 低レイテンシ要件：リアルタイムチャットボットやインタラクティブアプリ
向いていない人
- 極小规模利用：月間1万トークン以下の個人開発者（他サービスでも問題なし）
- 公式サポート必須：SLA保証없는サービスを探している企業
- 指定モデル限定：HolySheepが対応していない特定のモデルだけが必要な方
よくあるエラーと対処法
エラー1：QuotaExceededException（配额超過）
# 错误内容
QuotaExceededException: テナント enterprise_customer_a の配额を超過: 50000/50000
原因
日次配额の上限に達した
解決策
quota_manager.update_tenant_quota("enterprise_customer_a", daily_limit=100000)
または別の手配
1. 翌日になるまで待つ
2. 月次配额を確認: quota_manager.get_usage("enterprise_customer_a")
3. 不要なテナントの配额を回收して再分配エラー2：CircuitBreakerOpenException（熔断器开启）
# 错误内容
CircuitBreakerOpenException: テナント startup_customer_b 熔断中。45秒後に再試行
原因
短時間内に連続してAPI呼び出しが失敗した
解決策
import time
推奨: 指数バックオフで再試行
def retry_with_backoff(func, max_retries=3):
for attempt in range(max_retries):
try:
return func()
except CircuitBreakerOpenException as e:
wait_time = 2 ** attempt * 10 # 10, 20, 40秒
print(f"再試行まで {wait_time}秒待機...")
time.sleep(min(wait_time, e.retry_after))
# 上限を超える場合は альтернативный プロバイダーに切り替え
raise Exception("HolySheep APIが利用不可。代替エンドポイントを使用してください")
熔断器の手動リセット（紧急時のみ）
quota_manager.circuit_state["startup_customer_b"] = {