Migration doesn't have to be painful. Whether you're starting fresh or replacing an existing system, Reins slots in without disrupting your agents.
Coming from Helicone: Reins imports your rate limit configs directly. Keep Helicone for observability while Reins handles enforcement. Install the SDK alongside your existing Helicone proxy — no need to remove anything during migration. Average transition: 45 minutes.
Coming from Langfuse: Langfuse excels at tracing; Reins adds the governance layer. Export your scoring rules and we'll convert them to Reins policies. The SDK wraps your existing LangfuseClient without conflicts. Average transition: 30 minutes.
Coming from Custom Scripts: Replace fragile if/else spend limits with declarative policies. Export your thresholds as JSON, paste them into the Policy Migration Assistant below, and Reins generates production-ready rules. Average transition: 1-2 hours depending on complexity.
Starting Fresh: The fastest path. No exports, no conversions — just install the SDK, pick a policy template, and enable parallel mode. You'll have full spend visibility in under 20 minutes.
Pick the path that matches your current setup.
No existing spend tracking? This is the cleanest path. You'll set up Reins from the ground up with sensible defaults and industry-standard policy templates.
Already using Helicone or Langfuse for observability? Add Reins alongside — no need to replace your existing stack. Reins handles governance while your observability tool continues tracing.
Custom spend limits scattered across your codebase? Replace brittle code with declarative policies. Reins handles the enforcement logic so you can delete those maintenance-heavy scripts.
Seven steps from your current setup to full spend governance.
If you have existing spend limits or transaction logs, export them for import into Reins. Skip this step if starting fresh.
# Export from custom scripts (example)
cat spend_limits.json
# Or extract from environment variables
env | grep SPEND_LIMIT > policies_export.json
# From Helicone
curl -H "Authorization: Bearer $HELICONE_KEY" \
https://api.helicone.ai/v1/rate-limits > helicone_export.json
Don't have formal policies? That's fine. Skip to Step 2 — Reins will help you build policies from your actual spend patterns during parallel mode.
Sign up at reins-rh6x.polsia.app, create your organization, and generate an API key from Settings.
# Your API key will look like:
REINS_API_KEY=rns_live_k8x92mf4a7b3...
API key not appearing? Check that your email is verified. Organization admins can also generate keys from the team settings page.
Add the Reins SDK to your agent project. Available for Python and JavaScript/TypeScript.
# Python
pip install reins-sdk
# JavaScript / TypeScript
npm install @reins/sdk
# Python — initialize
from reins import Reins
reins = Reins(api_key="rns_live_k8x92mf4a7b3...")
reins.wrap(openai_client) # Wraps existing client
// JavaScript — initialize
import { Reins } from '@reins/sdk';
const reins = new Reins({ apiKey: 'rns_live_k8x92mf4a7b3...' });
const wrappedClient = reins.wrap(openaiClient);
Seeing import errors? Ensure you're on Python 3.8+ or Node 16+. The SDK uses modern async patterns that require these minimum versions.
Import your exported policies or start with a template. Policies define spend limits, rate controls, and alert thresholds.
{
"name": "Production Spend Limit",
"rules": [
{
"type": "budget_cap",
"limit": 500.00,
"period": "daily",
"scope": "organization",
"action": "alert_then_block"
},
{
"type": "per_call_limit",
"limit": 5.00,
"vendor": "openai",
"action": "block"
},
{
"type": "rate_limit",
"max_calls": 1000,
"period": "hourly",
"scope": "agent",
"action": "throttle"
}
]
}
Not sure what limits to set? Start with the "permissive" template — it alerts at high spend without blocking. You can tighten thresholds after observing real patterns in parallel mode.
Enable parallel mode where Reins observes and logs all spend without blocking any calls. This validates policy accuracy before enforcement.
# Enable parallel (observe-only) mode
reins.configure(mode="parallel")
# Or via API
curl -X PATCH https://api.reins.dev/v1/config \
-H "Authorization: Bearer $REINS_API_KEY" \
-d '{"mode": "parallel"}'
No data appearing in the dashboard? Verify the SDK is initialized before your first API call. Check that the API key matches your organization — keys are org-scoped.
Once parallel mode confirms your policies match expected behavior, switch to enforcement. Reins will now actively block calls that violate policies.
# Switch to enforcement
reins.configure(mode="enforce")
# Verify enforcement is active
status = reins.status()
assert status.mode == "enforce"
print(f"Enforcement active since {status.enforced_at}")
Want a gradual rollout? Enable enforcement for a single agent first using agent-scoped policies, then expand to the full organization once verified.
Once Reins is enforcing and you've verified the audit trail, remove your old spend tracking code or disable the previous tool.
# Remove old custom spend checks
# Before:
if get_daily_spend() > LIMIT:
raise SpendLimitExceeded()
# After (delete the above — Reins handles it):
result = reins_client.call(model="gpt-4", messages=msgs)
# Uninstall old dependencies
pip uninstall custom-spend-tracker
npm uninstall @internal/spend-limits
Keep old system configs archived (don't delete permanently) for 30 days. If you need to rollback, having the old config available saves time.
Paste your existing policy configuration and we'll convert it to Reins format.
Estimate your migration time based on your team's setup.
Reins can be disabled without data loss. Your agents keep running — governance just pauses.
Immediately stops enforcement while keeping observation active.
reins.configure(mode="parallel") # Stops blocking, keeps logging
Remove the Reins wrapper entirely — your original client works unchanged.
# Python: swap back to unwrapped client
client = openai.OpenAI() # Original, no Reins
// JS: use original client
const client = new OpenAI({ apiKey: process.env.OPENAI_KEY });
If you kept your previous scripts archived, restore them from your backup.
# Restore from archived config
cp spend_limits.backup.json spend_limits.json
# Re-enable old middleware
export USE_LEGACY_LIMITS=true
Download all logs and policy data before fully disconnecting.
curl https://api.reins.dev/v1/export \
-H "Authorization: Bearer $REINS_API_KEY" \
-o reins_data_export.json
Need to disable immediately? This single command kills all enforcement in under 30 seconds:
curl -X POST https://api.reins.dev/v1/emergency-disable \
-H "Authorization: Bearer $REINS_API_KEY"
# Response: {"status": "disabled", "resumed_at": null, "all_agents": "unblocked"}
Data is retained for 90 days after disabling. Re-enable anytime from the dashboard.
Quick reference: what Reins does that alternatives don't.
| Feature | Manual Tracking | Helicone | Langfuse | Custom Scripts | Reins |
|---|---|---|---|---|---|
| Real-time enforcement | ✗ | Partial | ✗ | Partial | ✓ |
| Policy-as-code | ✗ | ✗ | ✗ | DIY | ✓ |
| Multi-vendor support | ✗ | ✓ | ✓ | Manual | ✓ |
| Audit trail | Spreadsheet | ✓ | ✓ | ✗ | ✓ |
| Alert webhooks | ✗ | Limited | Limited | DIY | ✓ |
| SDK support | ✗ | ✓ | ✓ | ✗ | ✓ |
| Migration time | N/A | Hours | Hours | Days-Weeks | < 1 hour |
| Cost visibility | Delayed | ✓ | Partial | DIY | ✓ |
Learn from others' mistakes. Six things to avoid during migration.
Jumping straight to enforcement without testing policies against real traffic. Results in false blocks on critical agent workflows.
Wrapping every agent simultaneously makes it impossible to isolate issues. One misconfigured policy can cascade across the fleet.
Setting aggressive limits on day one without understanding baseline spend patterns. Agents get blocked and workflows break.
Policies enforce silently without notifying anyone. Team discovers blocked calls hours later when agents stop producing output.
Running outdated SDK versions that don't support latest policy types or vendor integrations. Silent failures with no error messages.
reins.healthcheck() on startup to catch compatibility issues early.Old spend tracking code still running alongside Reins. Conflicting enforcement, double alerts, and confused team members.
Verify everything is working. Progress is saved to your browser.