EVE SDK

One obvious entry point per language to govern tool calls, produce signed evidence, and verify it offline.

Who this is for

Engineers integrating EVE governance into an application or agent. You want a small, dependency-light client with a single primary entry point, a clear deployment model, and fail-closed behavior — plus an offline verifier that holds no secrets.

The problem

Governance clients often bury the real entry point, silently fall back to permissive behavior when the service is down, or bundle signing code into places it should never live. You want a client that imports cleanly outside your repository, governs through a defined mode, fails closed on error, and — on the verify side — never signs and never holds secrets.

Supported capabilities

  • Python client. The primary Python entry point is from eve_coreguard import EVE; a fresh wheel installs outside the repository and imports from site-packages. Version 0.2.2; a release-candidate core client (sdks/coreguard/eve_coreguard/).
  • TypeScript client. The primary TypeScript entry point is import { EVE } from "@eve/coreguard"; a fresh npm project installs the tarball and governs via hosted mode with a browser-safe offline verifier. Version 0.1.0-rc1; ESM, Node ≥18 (packages/eve-coreguard-ts/).
  • Deployment modes, fail-closed. EVE supports embedded (in-service), hosted, sidecar, MCP-gateway, and sovereign/offline modes. In every mode, a service error fails closed — no SDK silently falls back to permissive behavior.
  • Framework adapters. EVE ships framework adapters that route tool calls through the same governance composition root. The generic adapter is validated; others are experimental.

Readiness: the Python and TypeScript clients and deployment modes are PILOT_READY (release-candidate core clients). Framework adapters other than generic are EXPERIMENTAL.

How it works

  • Python governs via hosted, sidecar, or embedded(service) modes. The pip client reaches CoreGuard over hosted mode (needs an endpoint); embedded in-process governance is the EVE service, not the client wheel.
  • TypeScript governs via hosted or sidecar mode and ships a browser-safe offline verifier. Embedded mode is Python/service-only in TypeScript (it throws SDK_TS_EMBEDDED_UNSUPPORTED). The TS SDK never signs and holds no secrets.
  • On service error in any mode, the SDK fails closed — it raises or returns BLOCK, never a silent ALLOW.

Technical example (Python)

The release-candidate clients are distributed privately for pilots — install the pilot artifact, not a public pip/npm install (see readiness for public-registry status). Install the provided eve-coreguard 0.2.2 wheel, then:

from eve_coreguard import EVE

# hosted mode
eve = EVE(policy="enterprise-default", mode="hosted",
          endpoint="https://your-endpoint", api_key="eve_sk_...")

result = eve.govern_tool_call(
    tool="send_email",
    arguments={"to": "user@example.com", "body": "…"},
    context={"tenant_id": "org_abc", "principal_id": "u_1", "session_id": "s_1"},
)
print(result["action"])  # ALLOW | BLOCK | MODIFY (govern_tool_call returns a dict)

Technical example (TypeScript)

Install the provided @eve/coreguard 0.1.0-rc1 tarball into a Node ≥18 ESM project:

import { EVE } from "@eve/coreguard";

// hosted mode
const eve = new EVE({ policy: "enterprise-default", mode: "hosted",
                      endpoint: "https://your-endpoint", apiKey: "eve_sk_..." });

const result = await eve.governToolCall({
  tool: "send_email",
  arguments: { to: "user@example.com", body: "…" },
  context: { tenantId: "org_abc", principalId: "u_1", sessionId: "s_1" },
});
console.log(result.action); // ALLOW | BLOCK | MODIFY

Signed evidence example

A governed decision returns an evidence envelope:

{ "content_hash": "…", "canon": "jcs-1", "signature": "ed25519-…", "decision": { "action": "BLOCK", "decision_id": "…" } }

Verifier example

from core.eve_sdk import verify_evidence
report = verify_evidence("decision", envelope)  # {"valid": True, "reason": "certificate verified", "checks": {...}}

import { verifyEvidence } from "@eve/coreguard";
const report = verifyEvidence(envelope, { publicKeyPem }); // { valid: true, signature: "ed25519-valid" }

Deployment options

Embedded (in-service), hosted, sidecar, MCP-gateway, and sovereign/offline. Hosted and sidecar modes require a reachable endpoint. Production configuration refuses to disable signed evidence, strict verification, distributed consumption, fail-closed behavior, authenticated identity, or complete scanning.

Readiness

The Python client (eve-coreguard 0.2.2) and TypeScript client (@eve/coreguard 0.1.0-rc1) are release-candidate core clients, PILOT_READY. Deployment modes are PILOT_READY and fail closed. Signed evidence and offline verification are SUPPORTED. Framework adapters other than the generic adapter are EXPERIMENTAL. The EVE SDK core overall is a RELEASE CANDIDATE WITH EXCLUSIONS.

Limitations

  • The pip eve-coreguard client governs via hosted mode (requires an endpoint); embedded in-process governance is the EVE service, not the client wheel.
  • The TypeScript SDK is ESM, Node ≥18. Embedded mode is unsupported in TypeScript (throws SDK_TS_EMBEDDED_UNSUPPORTED). The TS SDK never signs and holds no secrets.
  • Only the generic framework adapter is validated. Others (OpenAI Agents, Claude Agent SDK, LangChain, LangGraph, CrewAI, Vercel AI SDK) are experimental and untested against pinned live versions; wrapper-enforced adapters are bypassable by a direct underlying-tool call; Claude Code hooks are cooperative and are not an unbypassable boundary. Hard enforcement requires a gateway or sidecar.
  • The release-candidate clients are distributed privately for pilots — install the pilot artifact, not a public pip/npm install (see readiness for public-registry status).

Next step

Request pilot access to the eve-coreguard wheel and the @eve/coreguard tarball, and integrate against a hosted endpoint in your environment.

Part of the EVE AI Core control plane Deterministic AI Governance Control Plane → Policy decisions that return the same result for the same input every time, before execution.