Inbound vs Outbound: The Two Postures of Agents-as-a-Service

One of our agent crews reviews defense contracts. Another spends its days attacking a bank. They're the same kind of thing — and seeing why takes about three minutes.

A defense procurement contract lands: hundreds of pages of schedules, exhibits, and clauses that modify other clauses. A crew of AI agents reads it against a requirement checklist and hands back a ledger of verdicts, each one pinned to the exact passage that justifies it. Review work that took analyst-weeks comes back in hours.

Somewhere else in our portfolio, a different crew spends the afternoon attacking a bank. The bank is staged — a security-exercise scenario — but the work is real: one agent probes for weaknesses, another defends. No customer will ever meet either of them. That's the job description.

The first crew is a product. The second crew is staff. When people say "we use AI agents," they usually mean one of these two things without noticing there was a choice — and the difference matters more than the model, the framework, or the vendor.

Inbound: the crew is the product

The contract crew is Argus, our contract-intelligence proof-of-concept. Its user never sees an agent. They see a dossier: every requirement resolved to met, partial, or gap, and every verdict grounded in a discipline of three words — Requirement → Proof → Evidence. The multi-pass retrieval underneath, the clause assembly, the panel of three reviewer judges voting to consensus: all of it stays below the waterline. The user experiences a result.

That's the inbound posture. Agents power what the user experiences — an answer, an analysis, a document reviewed — and the crew is what's underneath. Argus earns far more than a paragraph, and it has one: a full teardown, linked at the end of this piece. Hold that thought.

Outbound: the crew runs the company

Point the same machinery inward and you get the other posture. Outbound agents never touch an end user. They build, test, secure, and market the business itself.

Our public engine demo stages this side as red versus blue: CHIMERA, a red-team persona, probes a banking scenario for weaknesses while SENTRY defends it — a red agent on one model attacking, a blue agent on a different model defending, both orchestrated by the same conductor.

Vigil, our monitoring tool, works this posture in earnest. Its triage agent, vigil-router, runs cheap and fast on Groq's Llama 3.3, because high-volume bug triage should cost next to nothing. Its coding agent, vigil-coder, spends real money on Claude Sonnet, because code reasoning is worth the spend. Two agents, two models, two cost tiers — and zero end users between them.

One engine, facing both directions

Here's the move that makes this an architecture rather than a coincidence: both postures are designed to converge on one engine — the outbound side already runs on it, while Argus is wired to the same seam and flips over as planned (it doesn't run on it yet — the honesty notes below keep that straight). The engine is Nexus, the harness above the vendors — one layer between the entire portfolio and eight model providers, built to enforce a single rule: no product calls an LLM provider directly.

Every request, whichever way the crew faces, walks one governed path — auth → KeyVault → agent catalog → 7-layer memory → system prompt → provider routing → SSE stream → SXC metering — and the two postures are that same path pointed at different consumers:

                       ONE GOVERNED ENGINE
       auth → keys → catalog → memory → route → stream → meter
                   │                         │
     ◄── INBOUND ──┘                         └── OUTBOUND ──►
     the crew IS the product          the crew RUNS the company
     the user sees a result           the user never appears

     Argus — contract verdicts        CHIMERA vs SENTRY — red-blue
     backed by evidence               drill on a banking scenario
                                      Vigil — bug triage + code fixes

If the embed doesn't show in your reader: the same interactive, standalone — an inbound request and an outbound request walk the same engine, one after the other. The repetition is the message.

The catalog is the steering wheel. Each agent is a database row, not code — the row carries its model and its cost tier — so when a better model ships, the swap is one row, and both sides of the company get the upgrade the same afternoon.

Two honesty notes, because the source pieces make them plainly. Nexus is a live internal substrate — deployed, load-bearing, the engine behind our own portfolio — not a public SaaS you can sign up for. And Argus doesn't run on it yet: every model call in that crew already funnels through one seam cut to match the engine's entry point, so graduating onto Nexus is a planned flip, not a rewrite. The Vigil agents are already catalog rows.

Most companies pick one by accident

Teams adopting agents usually land in a single posture and never notice the other exists. The inbound-only shop ships smart features while it still runs itself by hand. The outbound-only shop automates its back office while its product stays dumb. Neither is wrong. Both are half.

Run both on one governed engine and the halves start compounding: a sharper router, a deeper memory, a cleaner audit trail — each improvement lifts the products and the company that builds them at once. That duality is how a small team operates a whole portfolio, because the crews powering the products and the crews testing, securing, and marketing them are the same class of thing, built once, governed the same way. The full argument — what the engine is, and why governance is the half everyone skips — is in the flagship case for an AI operating system.

The teardown is live: we open Argus all the way up — how a crew of governed agents reviews a defense contract in hours, why the number-one retrieval failure is a vocabulary gap, and what it takes to back every verdict with evidence.

---

Previously in this series: the flagship case for an AI operating system — the worldview this piece is drawn from — and Nexus, the harness above the vendors — the engine itself.

Up next: the Argus teardown — inside the contract crew, verdict by verdict — and its explainer on evidence-backed verdicts — what "backed by evidence" actually takes.