I’m curious how people here are thinking about managing agentic LLM systems once they’re running in production.

[Bryan @ Aden (bryanadenhq)]

Beyond basic observability, things like instrumentation, runtime control, and cost management seem to get complicated quickly as soon as you have multiple agents, tools, and models involved. In particular, it feels hard to reason about cost and token usage at the agent level, apply guardrails or budgets at runtime, or debug and compare agent runs in a structured way rather than just reading logs after the fact.
I’m interested in hearing how others are approaching this today. What parts are you building yourselves, what’s working, and where are you still feeling friction? This is just for discussion and learning, not pitching anything.

[Vladyslav Shapovalov (KeepALifeUS)]

Great question — I've been running multi-agent systems in production and here's what I've learned:

The core problem: Traditional logging doesn't work well for agents. You end up with thousands of log lines where the "why" is buried in conversation history, and replaying issues requires reconstructing the exact state.

What's worked for me:

1. Shared state as the source of truth

Instead of agents passing messages directly, they read/write to a structured shared state:

state = {
    "tasks": [],
    "agent_decisions": {},
    "token_usage": {"sales": 0, "scheduler": 0},
    "errors": []
}

This gives you:

• Instant observability — just read the state file
• Per-agent cost tracking — each write includes token count
• Deterministic replay — feed the same state, get the same behavior

2. Token budgets at the architecture level

Rather than per-request limits, I budget at the workflow level:

if state["token_usage"]["total"] > WORKFLOW_BUDGET:
    state["status"] = "paused_for_review"

This catches runaway agents before costs explode.

3. Structured diffs for debugging

Every state mutation is logged as a diff:

Agent: scheduler
Changed: tasks[2].status: "pending" → "completed"
Tokens used: 847

Way easier than reading conversation logs.

Where I still feel friction:

• Testing agent behavior changes (no good "unit test" equivalent)
• Handling partial failures in multi-step workflows
• Comparing agent versions systematically

Working implementation with these patterns: https://github.com/KeepALifeUS/autonomous-agents

The key insight: make the coordination layer the observability layer. If agents coordinate through explicit state, you get production visibility for free.

[Joy-0403]

I like the idea of setting budgets at the workflow level. One thing I'm curious about is how this works with parallel agents. A few calls could all start under the limit and push the total way over before any of them finishes. Do you reserve some budget before each agent starts, or just allow a bit of overshoot?

[Devon (devonakelley)]

+1 on the partial failures point. That's the hardest one. A multi-step workflow where step 3 of 5 returns something subtly wrong and the whole chain keeps going with bad data. By the time you notice, the damage is done.

The approach I've been taking with Kalibr is to let you report outcomes at the workflow level and have routing adjust based on that. If a model starts producing outputs that lead to downstream failures, it shifts traffic before the pattern repeats. Less about logging what happened, more about automatically preventing it from happening again.

Would be curious how you're handling the "partial failure" detection side of things though. That feels like the hardest problem to even define, let alone automate.

[Corey nida (xXMrNidaXx)]

Production agentic systems are our bread and butter at RevolutionAI (https://revolutionai.io)! Here is what we have learned:

Monitoring:

• Track task completion rates, not just uptime
• Alert on reasoning loops (agent stuck in circular logic)
• Monitor token burn per task — runaway agents are expensive

Reliability:

• Circuit breakers on tool calls — fail fast, retry smart
• Graceful degradation paths when agents cannot complete tasks
• Human escalation triggers for edge cases

Debugging:

• Full conversation replay capability
• Decision point snapshots for post-mortems
• A/B testing agent configurations in shadow mode

Cost control:

• Token budgets per agent per task
• Caching for repeated reasoning patterns
• Smaller models for classification, larger for generation

The hardest part is defining "done" — agents can always try harder. Setting clear success criteria upfront is crucial!