Skip to content

Technology

Robust by design. Intelligent by default.

The methods, architecture and tools behind every Logi Layer build. Engineered to think, scale and stay secure.

  • Typed end to end
  • Model agnostic
  • Human in the loop
  • Observable in production
ask.ts
1// every model call passes the same guardrails
2const answer = await layer.ask({
3  input,
4  redact: ["pii", "secrets"],
5  route: { prefer: "quality", fallback: "llama" },
6  ground: { source: "knowledge", cite: true },
7  validate: InvoiceSchema,
8  approve: (a) => a.impact === "high",
9});
illustrative, simplified

01How we build with AI

AI accelerates the work. Engineers own the decisions.

Agentic tools draft, test and scan. People plan, review and approve. Every change follows the same seven steps.

  1. 01Plan

    The problem is broken into small, reviewable changes before any code is written.

  2. 02Generate

    AI agents draft code, tests and docs against our own conventions.

  3. 03Test

    Type checks, unit, integration and end to end tests run on every change.

  4. 04Scan

    Secrets, vulnerable packages and OWASP risks are checked automatically.

  5. 05Review

    An engineer reads, questions and approves. Nothing merges without a person.

  6. 06Ship

    Preview first, then a zero downtime release with instant rollback.

  7. 07Observe

    Traces, errors and evals in production feed the next plan.

02AI architecture

Every model call, guarded end to end.

The reference architecture behind the AI features we ship. Swap any model, keep every safeguard.

  1. Your appweb, mobile, agents
  2. Gatewayauth, rate limits
  3. Guardrailsinjection check, PII redaction
  4. Orchestratorrouting, retrieval, tools via MCP
  5. ModelsClaude, GPT, Gemini or open models
  6. Validateschema, grounding
  7. Human approvalhigh impact only
  8. Observabilitytraces, cost, latency, evals

Grounded, not guessing

Answers come from your own data through permission aware retrieval, with citations a person can check.

Tools with boundaries

Agents act only through scoped tools exposed via MCP, each with least privilege and an audit trail.

Measured continuously

Evals run in CI like tests. Prompts, models and cost are versioned and compared before anything ships.

Private by default

Personal data is redacted before any model call, providers are chosen for zero data retention and in region hosting where available, and your data never trains a model.

03Engineering principles

Four rules every build follows.

Tested · typed · observable

Robust

Every line is type checked and covered by tests, and every service reports how it is doing.

Simple · durable · no bloat

Rustic

We choose the plainest design that solves the problem, so it is cheap to run and easy to change.

Fails safe · recovers fast

Resilient

Timeouts, retries and fallbacks are designed in, so one failure never becomes an outage.

Secure · explainable AI

Responsible

AI decisions are logged, explainable and reversible, with a person in the loop where it matters.

04Delivery and reliability

Shipped often. Rolled back instantly. Watched always.

  • Every changeType checks, tests and security scans in CI before anything merges
  • Every pull requestIts own preview environment, reviewed by an engineer
  • InfrastructureDefined as code with Terraform and reviewed like any other change
  • ReleasesZero downtime deploys, feature flags and instant rollback
  • OperationsService level objectives with alerts that reach a person
  • VisibilityTraces, metrics and logs through OpenTelemetry
  • RecoveryBackups proven by restoring them, not just taking them

05Edge architecture

From the device to the dashboard, reliably.

Gateways keep collecting when the network drops, encrypt every message, and replay in order when it returns.

  1. Devicesbiometric readers, IP cameras, PLCs, sensors
  2. Edge gatewaybuffers offline, encrypts
  3. BrokerMQTT over TLS
  4. Streamordered, replayable
  5. Platformdashboards, alerts, APIs

06The stack

Enterprise stack. Startup speed.

Proven, well supported tools, chosen per problem and never for fashion.

Interfaces
Next.jsReactTypeScriptReact Native
Fast, accessible interfaces in one language across web and mobile.
Services
Node.jsPythonGoGraphQLgRPC
The right runtime per job: product APIs, data and AI work, high throughput services.
Data
PostgreSQLRedisKafkapgvector
Transactional storage, caching, streams and vector search on proven foundations.
AI
ClaudeGPTGeminiLlamaMCPEvals
Model agnostic by design, measured before and after every change.
Cloud
AWSAzureGCPKubernetesTerraform
Portable infrastructure, defined as code, in the region you choose.
Edge
MQTTOPC UAModbusONVIFRTSP
Open protocols, so devices stay replaceable and data stays yours.
Security
VaultCloud KMSDependabotTrivyOWASP ZAP
Secrets managed centrally, dependencies and containers scanned, apps tested like an attacker would.
Delivery
GitHub ActionsPlaywrightOpenTelemetrySentry
Automated checks and full visibility from commit to production.

Architecture review

See how this would work for your system.

We will sketch the architecture for your use case, including models, data flow, security and running cost.

Request a review