// technology

Engineering Intelligent API & AI Platforms

We do not only integrate platforms other people built. We architect and operate production API and AI platform layers of our own: contract-first REST surfaces, asynchronous execution, multi-model inference routing and governed, auditable work distribution.

API Engineering Capabilities

  • Contract-first REST design. The OpenAPI 3.1 document is the source of truth, not documentation written afterwards. Bare-AI publishes 78 paths and 86 operations, with machine-readable request contracts and defined validation schemas covering typed models such as RunRequest and RouteRequest.
  • Asynchronous execution. Long work is submitted then polled: POST to start, GET status and result, plus cancel and delete. Requests never block on multi-minute jobs.
  • Scoped authentication and isolation. API-key auth with 13 discrete scopes, per-key quotas and an audit trail on every call. A credential can only narrow its entitlement, never widen it.

AI Platform Engineering

  • Multi-model orchestration. One key across 50 models, 31 of them council-enabled: single model, several in parallel, or a multi-round debate that converges on a consensus answer.
  • Cost and residency aware routing. Routing picks the cheapest eligible model for a stated strategy with a per-call EUR ceiling, provider exclusions and a residency constraint that fails closed.
  • Governance by construction. A claim pins an immutable execution-profile snapshot, including the role constitution SHA-256 and routing configuration, to the row. Separation of duties is enforced, so a worker cannot certify its own output and an independent reviewer must attest before the task closes.

Bare-AI: Live Architecture Showcase

Bare-AI is the platform we engineered to run this model end to end. It keeps its own product identity, contract and documentation; the topology below is what we build and operate.

Bare-AI production architectureEdge and WAF feed dual path-filtering ingress, which routes to stateless API gateway replicas. Requests travel a synchronous path to the caller; long-running work is handed to asynchronous Council and TaskBus execution workers. Secrets and machine identity are held in a vault outside the request path.Edge & WAFTLS · rate limiting · bot defenceIngress · public API pathfiltered route to /v1Ingress · internal pathsession and admin surfacesStateless API gateway replicashorizontally scaled · no session state on the nodesync202 + job idCouncil executionmulti-round debate workersTaskBus executionlease-bound task workersasyncSecrets & identity vaultmachine identity · key lifecycle · digest revocationsynchronous request pathasynchronous execution path
Architectural reference view. Layers and paths are shown, not individual hosts.

The contract is published, not implied: OpenAPI 3.1 document · API reference · Council platform · Orchestration docs · bare-ai.net

Representative API Workflows

Five of the workflows integrations use most. The shapes below are the published contracts; keys are placeholders and nothing on this page calls the live API.

POST/v1/council/route

Auth: X-API-Key (ApiKeyAuth)

Request body

{
  "strategy": "cheapest_under_ceiling",
  "ceiling_eur": 0.05,
  "residency": "eu",
  "exclude_providers": ["example-provider"],
  "estimate_input_tokens": 1200,
  "estimate_output_tokens": 600,
  "limit": 3
}

Response

{
  "strategy": "cheapest_under_ceiling",
  "candidates": [
    {
      "model_id": "example-model-a",
      "provider": "example-provider-a",
      "residency": "eu",
      "estimated_cost_eur": 0.031
    }
  ]
}

Behind the scenes

Routing evaluates the eligible set before any work is scheduled: the strategy picks the cost dimension, the EUR ceiling and provider exclusions narrow the set, and an unrecognised residency token is rejected rather than ignored. The chosen model is disclosed before a job runs.

From Enterprise Integration to Intelligent Execution

This is an architectural reference pattern, not a claim that every connector below ships pre-built. It is the blueprint we use to take an enterprise from integration to governed automation.

1

Enterprise systems

Workday, SAP, Oracle and CRM estates remain the systems of record. Nothing is migrated to make the pattern work.

2

Apache NiFi & integration APIs

Ingestion, transformation and routing: NiFi moves record-level data in flight, while REST and SOAP APIs cover the request-driven paths.

3

Bare-AI orchestration

Model routing, multi-agent execution and the governance layer: leases, execution-profile snapshots, scoped credentials and auditable job history.

4

Intelligent business processes

Automated workflows, human-in-the-loop approvals and auditable outcomes, feeding results back into the systems that produced the data.

Enterprise integration is the prerequisite, not the destination. Once the data flows are reliable and the contracts are explicit, AI execution can be governed with the same rigour: leases, snapshots, scoped credentials and a reviewer who is not the author.

Enterprise Business Value

The discipline we apply to Workday and Apache NiFi integrations is what makes governed AI execution safe inside an enterprise: explicit contracts, auditable state, least-privilege credentials and a human decision point wherever the consequence matters.

Discuss Your Engineering Challenge

Have a complex integration or AI infrastructure challenge? We architect and engineer the APIs, data pipelines and intelligent platforms that make enterprise systems work together.

DISCUSS YOUR ENGINEERING CHALLENGEEXPLORE BARE-AI
Bare ecosystemBare-ConnectFi↗Bare-AI↗