Lucas Pavani

Engenheiro de IA 🤖 | N8N • RAG • Agentes Inteligentes | LLMs • Python • JS | ComfyUI | Automatizo negócios com IA 🇧🇷

[Lucas Pavani @Pavaniecom]

@0xlelouch_ At-least-once plus ordered per conversation puts all the weight on the dedup key. If the client derives it from content plus timestamp, a retry after clock skew mints a second message id and the receiver sees a duplicate that ordering cannot collapse.

[Lucas Pavani @Pavaniecom]

@ClaudeDevs Centralizing at the IdP fixes onboarding and moves the hard part to attribution. With an org-scoped token, the tool call proves the org had access, not which user asked. Does the end-user identity travel down to the connector, or stop at the gateway?

[Lucas Pavani @Pavaniecom]

@omarsar0 @agentsky_dev Same-task harness comparison is only honest if the denominator is completed tasks, not runs. A $2 run that needs three attempts and a human fixing the diff is not the cheap one. Does it track attempts-to-accept next to tokens?

[Lucas Pavani @Pavaniecom]

Where the fix lands in the wrong place: a SQL linter, or a second model reviewing the query. Both approve, because the query is correct. The mismatch sits between the grain of the result and the grain of the question, and neither reviewer ever saw the question.

[Lucas Pavani @Pavaniecom]

SQL agents rarely get the syntax wrong. They get the grain wrong, and hand back a round number nobody questions.

[Lucas Pavani @Pavaniecom]

What fixed it: the model stopped writing SQL. It picks a reviewed query from a small catalog and fills parameters. Aggregation lives inside the query, grain decided outside the prompt. A question outside the catalog becomes an explicit refusal instead of a wrong number.

[Lucas Pavani @Pavaniecom]

@samsmallmind @realmadhuguru @OvermindLab Resampling fixes staleness. Selection is the part that survives it: prod stops sending the inputs the agent already fails on, because those users gave up. Our live slice only got honest after we fed it abandoned sessions instead of completed ones.

[Lucas Pavani @Pavaniecom]

Agent retries duplicate a charge and the log stays clean.

Generated code derives the idempotency key from a hash of the whole payload. The payload carries a timestamp. Timeout hits, the agent rebuilds the call, the hash changes, and the gateway sees two distinct requests. Two charges, two 200s, no error anywhere.

Identity has to come from the domain: order id plus logical attempt, written before the call leaves. Never from the serializer.

Teams usually fix the wrong layer and tune the retry backoff. Better backoff on a bad key only spaces the duplicate charges out. A clean log is not proof of a healthy system.

[Lucas Pavani @Pavaniecom]

The gap in stage 1 is that this stack watches the serving layer. An agent returning a confidently wrong answer keeps p95 flat and error rate at zero, so nothing pages. Agent reliability signal lives downstream: same user retrying, humans editing the output, reversals in the system of record.

[Lucas Pavani @Pavaniecom]

Point 2 is where most candidates stop one layer early. Building a test set demos well. Knowing what a green suite hides is the actual signal. Evals score the final answer, so a tool call that returned stale data still passes when the answer reads correct. Ask what their eval cannot see.

[Lucas Pavani @Pavaniecom]

The reset tax is real, and the shared brain has its own tax on the other side: constraints go stale. A restriction recorded three steps back gets inherited as law and nobody re-checks whether it still holds. Storing who decided it, and against what evidence, is what lets a later agent retire it.

[Lucas Pavani @Pavaniecom]

@omarsar0 More reviewers plateau because the errors correlate. Same base model, same context window, so they miss the same line together. Disagreement buys something only when the agents see different evidence: one on the diff, one on the runtime trace, one on migration history.

[Lucas Pavani @Pavaniecom]

Download is the easy part, and on Apple silicon the wall usually isn't the weights either. At Q4 a 27B fits, then memory bandwidth sets tokens per second and the KV cache grows linearly with context, so a setup that feels fine at 2k turns painful around 16k. Measure tok/s at the context length you actually work at, not on the first prompt.

[Lucas Pavani @Pavaniecom]

Routing on complexity and cost is the visible half. The part that bit us was the verified flag in the shared contract: it was computed by one harness against its own run, and the next harness inherits a verdict it cannot reproduce. Pinning each verdict to the commit sha it was computed on, then re-running the cheapest check at handoff, cost about 20 seconds and killed the whole class of ghost-green handoffs.

[Lucas Pavani @Pavaniecom]

The interface is the easy half. Most vendors port their REST surface 1:1 and ship 40 MCP tools, then the agent gets worse: descriptions eat context and selection accuracy degrades past a dozen. In practice what works is fewer, coarser, task-shaped tools. Repricing is the other half, since seat-based pricing breaks the moment the seat makes 200 calls an hour.

[Lucas Pavani @Pavaniecom]

Multi-agent failure mode nobody logs: silent promotion of a hypothesis into a fact.

The product agent writes an assumption to shared memory. The architecture agent reads it as an approved requirement, because the record carries no difference between the two. Text is text. Nobody errs, and the rework surfaces three steps downstream.

It's a schema problem, not a model problem. Shared memory stores content and a timestamp. Provenance is what's missing: who produced it, whether it was validated, which sensor validated it.

What held here: every write carries confidence level and origin, every read declares the minimum level it accepts. The implementation agent reads nothing below validated.

Where this gets applied in the wrong place: the prompt. "Treat this as a hypothesis" survives until the first context compaction. A constraint that has to hold across 40 turns lives in the record schema, not the instruction.

Agent governance is less about permission than about provenance.

[Lucas Pavani @Pavaniecom]

What would sharpen this comparison is splitting the extraction errors by cause: schema coerced the value, versus the model never read it.

Part of why coding harnesses hold up on long documents is that they retry against the file, not against their own last output. OCR tools have no such loop.

[Lucas Pavani @Pavaniecom]

The box these diagrams always draw too small is observation. It gets labeled "tool result" when what the loop actually needs is the state after the write.

Tool returns 200 with the wrong parameter, agent plans the next step on something that never happened, and nothing in the diagram catches it.