Deploy as a sidecar

Run EVE as a sidecar next to your application so tool calls are governed at a boundary that a direct in-process call cannot bypass. The client SDK talks to the sidecar over a reachable endpoint, and every decision fails closed on error.

Prerequisites

• The EVE service deployed as a sidecar with a reachable endpoint.
• The EVE client SDK (Python or TypeScript) configured for sidecar mode.
• Synthetic tools for testing; no production credentials.

Installation

pip install eve-coreguard        # Python client
npm install eve-ai-governance                 # TypeScript client (ESM, Node >=18)

Deploy the EVE service as a sidecar and note its endpoint (for example a loopback or unix-socket address on the pod).

Runnable code

Python client pointed at the sidecar:

from eve_coreguard import CoreGuardClient

# point base_url at the local sidecar endpoint
client = CoreGuardClient(api_key="eve_sk_...", base_url="http://127.0.0.1:8001")
result = client.evaluate(
    request_id="req-001",
    tenant_id="acme",
    proposed_action={"type": "loan_approval", "amount": 1000},
    model_output={"decision": "approve", "confidence": 0.9},
    context={"principal_id": "agent-1", "session_id": "sess-1"},
    policy_set="lending_v1",
    include_evidence=True,
)
print(result.decision.status, result.risk.level)

TypeScript — there is no TypeScript enforcement client; call the sidecar over the REST API:

// point the fetch at the local sidecar endpoint
const res = await fetch("http://127.0.0.1:8001/v1/decisions/evaluate", {
  method: "POST",
  headers: { Authorization: "Bearer eve_sk_...", "Content-Type": "application/json" },
  body: JSON.stringify({
    request_id: "req-001", tenant_id: "acme",
    proposed_action: { type: "loan_approval", amount: 1000 },
    model_output: { decision: "approve", confidence: 0.9 },
    context: { principal_id: "agent-1", session_id: "sess-1" },
    policy_set: "lending_v1",
  }),
});
const { decision, risk } = await res.json();
console.log(decision.status, risk.level);
if (decision.status === "BLOCKED") console.log(decision.action);

Expected result

• Governed calls return ALLOW / BLOCK / MODIFY from the sidecar.
• Because governance sits at a boundary, a direct call to the underlying tool that goes through that boundary is governed — unlike an in-process wrapper, which a direct call can bypass.

Evidence output

{ decision: { status: "ALLOWED", action: <...> }, risk: { level: "..." }, audit: { decision_id: "...", certificate: {...} } }

The certificate is signed (ECDSA P-384 (AWS KMS) in production configuration, HMAC-SHA256 fallback) and verifiable offline.

Verification

Verify a sidecar decision's evidence independently (see verify-evidence-offline.md):

# The pip client verifies offline with verify_decision_record;
# in TS use eve-ai-governance verifyDecisionCertificate.
from eve_coreguard import verify_decision_record

report = verify_decision_record(result.signed_governance)
print(report)

Failure example

If the sidecar is unreachable, the client fails closed — Python raises, TypeScript returns a BLOCK. No client silently falls back to permissive behavior on a sidecar error.

Production considerations

• The sidecar boundary gives enforcement that a direct underlying-tool call cannot bypass, unlike wrapper-enforced adapters; route side-effecting calls through it.
• Sidecar mode requires a reachable endpoint; treat endpoint failure as a deny condition in your design.
• The production configuration refuses to disable signed evidence, strict verification, distributed consumption, fail-closed behavior, authenticated identity, or complete scanning.

Limitations

• Sidecar is one of the supported deployment modes (embedded, hosted, sidecar, MCP-gateway, sovereign); deploy.modes is PILOT_READY. Hosted/sidecar require a reachable endpoint.
• Hard, non-bypassable enforcement of tool calls requires this gateway/sidecar boundary; wrapper-enforced adapters alone are bypassable by direct underlying-tool calls.
• The TypeScript client governs via hosted/sidecar mode and never signs; embedded mode is Python/service-only (SDK_TS_EMBEDDED_UNSUPPORTED).

Next step

If you cannot run a sidecar, use use-the-hosted-service.md; for air-gapped deployments, see sovereign-offline-mode.md.