Orvon
TR

Enterprise AI

AI that runs inside the enterprise, not beside it.

Most enterprise AI stops at the demo. Ours does not, because we start from the SAP process rather than from the model. We know what the nightly invoicing run actually does, which ABAP report owns it, and what breaks if you touch it. The automation we build drives the existing system instead of replacing it.

  • Non-invasive by default

    We wrap what already works. Existing SAP programs are driven, never rewritten. That is what makes an AI agent deployable on an accounting-critical process.

  • Deterministic where it counts

    Scoring and validation are deterministic at every stage; the model is invoked only at steps that have already passed their checks. Output stays auditable and reproducible.

  • On-premise when data demands it

    We design and deploy the GPU environment inside the customer network when residency requires it, so no client data leaves the organisation.

  • People before pilots

    Adoption is a training problem before it is an engineering one. We run literacy sessions for senior management and hands-on programmes for directors before anything reaches production.

Application examples

Process design

Agentic AI process design

We design agentic AI systems that automate multi-step business processes end to end, coordinating a chain of tool calls against the systems already in place instead of replacing them.

  • An orchestration layer sequences tool calls against existing systems instead of rewriting them.
  • Deterministic validation gates every step before the model is invoked, keeping output auditable.
  • Low-confidence steps are routed to a human reviewer instead of failing silently.

Deployable across accounting, logistics and operations processes alike.

Integration

SAP and non-SAP integrations

We connect agentic AI to both SAP and non-SAP systems, exposing existing transactions and services as callable tools rather than building a parallel system.

  • SAP web services and ABAP submit wrappers expose existing transactions as callable tools.
  • Non-SAP systems are integrated the same way, through their own APIs.
  • The underlying programs are driven, never rewritten.

One integration pattern across the whole landscape, SAP or not.

Deployment

On-premise and API-based deployment

Depending on data-residency requirements, we deploy self-hosted models inside the customer network or use cloud APIs — same architecture, different deployment target.

  • On-premise deployment when client data cannot leave the organisation.
  • Cloud API deployment when it can, for faster setup and lower operating overhead.
  • The same orchestration and validation layer runs on either path.

The deployment model follows the data, not the other way around.

How the technology actually works

The mechanics behind the principles on the left, in plain terms.

  • Attention mechanism

    The 2017 paper "Attention Is All You Need" laid the foundation for today's large language models. Earlier models read text left to right, one word at a time; the transformer architecture looks at an entire sentence at once and learns how much “attention” to give each word. That is how it resolves what a pronoun like “it” refers to purely from context.

  • Embeddings: meaning as numbers

    A model cannot read text directly; it converts every word into a high-dimensional vector. Words that are close in meaning sit close together in that space, and real arithmetic works on the representation: “king − man + woman” lands nearest to “queen.”

  • Tokens & context window

    Models process text as tokens, not words — roughly 0.75 tokens per word on average, with Turkish consuming noticeably more tokens than English for the same content due to its agglutinative structure. The context window is the total space a model can “see” at once: a larger window means longer documents in a single pass, but filling it affects both cost and response quality.

    A few pages 8KA long report 32KA short book 128KA small book series 1M
    What different context window sizes actually hold.

    Across today's AI models, context windows commonly range from a few thousand to well over a million tokens; a larger window means more text in a single pass, but it affects both cost and response quality.

  • Why hallucination is a structural risk

    A model does not “know” the truth; it predicts the next most likely word. It does not distinguish correct information from incorrect, so whatever appeared more often during training was learned more strongly — which makes specific numbers, dates and lesser-known names high-risk. We manage this by grounding output in a source, running critical steps through deterministic validation gates, and letting the model act only at steps that have already passed those checks.

  • The six parts of a good prompt

    A well-built prompt has six parts: role, task, context, format, example and constraint. Because a transformer weighs every word in the context when producing each token, a specific, structured input gives the model a much stronger signal. The same logic is why prompting a model to “think step by step” (chain-of-thought) helps on multi-step problems — the intermediate steps are produced as tokens and make the final result more robust.

  • A markdown-first knowledge base

    Instead of embedding company knowledge straight into a vector database, we first convert it into verifiable, human-readable markdown. Vectorizing unverified data just makes messy data searchable faster — correct comes before fast. The vector/RAG layer is only built on top of that verified foundation: lightweight, version-controlled, and useful long before a months-long platform build would show any value.

Have an S/4HANA or AI programme on the table?

Share the scope and the timeline with us, and let's work out together how we can add the most value.