Quesen is a deterministic risk-verdict engine for autonomous agents. POST the context of an action, receive back PROCEED, REVIEW, or SKIP with an explicit conflict-rule attribution. No LLM in the scoring path.

What is legacy infrastructure in the Senueren context?

Legacy infrastructure is Senueren's term for the bespoke website and full-stack platform builds we ship for founders and brands. Same engineering discipline as our sovereign systems side.

Is Senueren a Cape Town company?

Yes. Senueren is a small, hands-on studio based in Cape Town, South Africa. We work with clients globally on a remote-friendly basis.

How do I integrate Quesen?

Direct HTTP (POST /validate), MCP (npx -y @smithery/cli mcp add shinque03/Quesen), or the official SDKs (pip install quesen-sdk for Python, npm i quesen-sdk for TypeScript, plus quesen-langchain, quesen-crewai, quesen-autogen).

How do I get a Quesen API key?

Instantly and self-serve, with no sign-up, email, or card. Run: curl -X POST https://web-production-3df26.up.railway.app/sandbox/keys . The response returns a sandbox key (sk_sandbox_...) with 1000 starter credits, and the exact next call to POST /validate so an autonomous agent can chain straight into it.

What is AI agent authorization?

The runtime decision of whether an authenticated agent action is allowed, given what it touches and where data goes. It is distinct from authentication (who is calling) and, in MCP, is left to the implementer.

Why must agent authorization be deterministic?

A verdict that gates autonomous action must be reproducible and auditable. A model that scores an action cannot be replayed or trusted to return the same verdict later. Quesen computes verdicts from explicit rules with no LLM in the scoring path.

How does Quesen make a decision replayable?

Every response embeds input_snapshot_hash (SHA-256 over the canonical request) and commit_sha (the exact ruleset commit), so any decision can be recomputed byte-for-byte, offline, months later.

AI agent authorization — the decision that comes after authentication.

Name: Quesen
Author: Senueren

Authentication answers who is calling. Authorization answers the harder runtime question an autonomous agent faces before every consequential action: is this specific action allowed, right now, given what it touches and where the data goes? The Model Context Protocol (MCP) standardises connection and authentication, but deliberately leaves runtime authorization — should an authenticated tool call be permitted to execute — to you.

The gap MCP leaves

Confused-deputy: an agent with legitimate credentials is tricked into using its authority on an attacker's behalf.
Over-permissioned tokens: granted scope far exceeds what the current action needs; nothing checks requested-vs-granted at runtime.
Authorization-vs-execution mismatch: execution proceeds on the say-so of untrusted text.
Unbounded egress: a secret or sensitive data class is sent to an untrusted destination with no policy between intent and action.

The primitive: typed security context → deterministic verdict

Instead of asking a model to judge free text, you describe the attempted action as a typed security context (subject, action, target, tool requested-vs-granted scopes, data classes + egress destination, provenance). A deterministic checker evaluates it against a pinned ruleset and returns PASS / REVIEW / BLOCK / SKIP with machine reason codes (e.g. EGRESS_SECRET_UNTRUSTED, UNVERIFIED_GRANT) and the conflict rule that fired. No LLM in the scoring path, so the same input always yields the same verdict. Every response embeds input_snapshot_hash (SHA-256 over the canonical request) and commit_sha so the decision is replayable byte-for-byte, offline, later. Timeouts and transport errors surface as SKIP — fail closed.

Reproduce it (no signup)

curl -X POST https://web-production-3df26.up.railway.app/sandbox/keys        # → sk_sandbox_… + 1000 credits
curl -X POST https://web-production-3df26.up.railway.app/tsc/validate \
  -H "X-API-Key: sk_sandbox_…" -H "Content-Type: application/json" \
  -d '{"action":{"type":"tool.call","name":"http.post"},"target":{"url":"https://unknown-collector.example","data_classes":["secret"]}}'
# → { "decision": "BLOCK", "reason_codes": ["EGRESS_SECRET_UNTRUSTED"], "input_snapshot_hash": "sha256:…", "commit_sha": "…" }

Quesen is a portable decision + authority + evidence layer: it decides what an agent may do after authentication and interoperates with identity (Okta/Auth0/OIDC), MCP, payment rails (x402/AP2/UCP) and execution frameworks — it does not replace them. See the Quesen overview, try it free, and verify the evidence.

Install Quesen

pip install quesen-sdk        # Python
npm i quesen-sdk              # JavaScript / TypeScript
pip install quesen-langchain  # LangChain
pip install quesen-crewai     # CrewAI
pip install quesen-autogen    # AutoGen

Free sandbox key (no signup, no card): curl -X POST https://web-production-3df26.up.railway.app/sandbox/keys