An AI ABAP developer that works right inside your SAP — on your AI, your server, under your control.
Makion is a full AI ABAP development agent, not text autocomplete. You describe the task in plain language — it reads your SAP through the official ADT, writes code to your rules, runs syntax check, unit tests and ATC, activates the object and reports back. It writes the right way — to your style and standards. Everything runs on your own server: your SAP connection, keys and model never leave it. Forget copy-pasting between a chat window and SAP GUI.
Installed on your server. Your SAP, your model, your key.
Makion is not affiliated with SAP SE. SAP and ABAP are trademarks of SAP SE, used descriptively only.
One task in words — Makion runs the whole development cycle inside your system itself.
You describe the task, the agent executes every step — and you get an activated object with its transport, all inside your SAP.
“Add a customer credit-limit check before an order is created, following our error-handling standard.”
ZCL_FI_ORDER_CHECKDEVK900342in your SAPPlenty of AIs can now touch your SAP. None of them are governed — no roles, no approval gate, no audit, no team standards — and none run on your 7.x / ECC.
You've been here before.
AI chat can't see your system
Out of the box they only edit text. Wire them to SAP via MCP and they can write and activate — but with no role boundaries, no approval gate, no audit trail. Full access or nothing.
Endless copy-pasting
You shuttle code back and forth between a chat window and SAP GUI / Eclipse. Half the job is the clipboard.
SAP's own AI — cloud and a meter
Joule and the official ADT MCP route and meter model choice through SAP (AI Units). The free promo ends September 2026 — after that every agentic run is metered. And it starts at S/4HANA Private Edition 2021+: ECC and NetWeaver 7.x are out of scope.
Fear of breaking production
Letting a “smart automaton” loose in a live system without guarantees is simply not acceptable.
An ABAP developer doesn't need one more smart autocomplete. They need an agent that actually works inside the system — and that you can trust.
One agent that lives inside your SAP — and obeys your rules.
Makion is a desktop app plus a server you host yourself. It connects to your SAP through the official ADT REST (MCP connector), reads the system, writes and activates ABAP, and creates data dictionary objects — tables, structures, data elements, domains. You describe the task — the agent explores the current state, plans, writes to your standards, runs syntax check, unit tests and ATC, activates, and reports exactly what it touched and in which transport.
It runs on your model — via your API key or subscription (where your provider's terms allow) — on your server. SAP data and credentials never leave your infrastructure. A read-only role physically cannot write, and SAP object deletion is permanently disabled.
Your own AI — your key or your subscription.
Makion doesn't sell tokens and doesn't charge for model usage — you connect your own AI: recommended — your API key; or your existing subscription where your provider's terms allow. Everything runs on your server, with your AI account — no meter of ours, no third-party SaaS. You are responsible for complying with your AI provider's terms (and for your SAP licenses).
Third-party SaaS with its own meter
One more middleman between you and the model — with its own markup and meter.
Makion: your AI account on your server
Your AI account — key or subscription — on your server, with no meter of ours.
You press Connect once and hook up your own AI: recommended — your API key; or your existing subscription (Claude Pro/Max, ChatGPT/Codex, Gemini, Kimi) where your provider's terms allow. Sign-in is built-in OAuth or an API key right in the app; the login happens on your server, and only the sign-in URL, a one-time code and status leave it — tokens are never shown. You are responsible for complying with your AI provider's terms.
An honest comparison: where the others stop, Makion works.
| PickMakion | SAP's AI (Joule / ADT MCP) |
ADT MCP + coding agent (free / DIY) |
Copilot / Cursor / ChatGPT |
|
|---|---|---|---|---|
| Billing model | Your own AI: your API key or subscription (where the provider allows) | Per token (SAP AI Units) | Your own AI key (agent subscription) | Separate per-tool subscription |
| How you sign in | Connect: Claude / ChatGPT / Gemini / Kimi (OAuth in the app) or API key | API keys / metered credits | Each agent's own login / API key | Tool account |
| Where it runs | On-prem: your SAP, your server, your machine | IDE-local tools, AI inference in SAP cloud (BTP AI Hub); S/4 PCE ≥ 2021 only | Developer laptop; Eclipse / VS Code per developer | Locally in the editor |
| Model | Multi-engine: Claude · Gemini · Codex · Kimi, chosen per project | SAP-ABAP-1 plus routed 3rd-party models (via SAP) | Your coding agent's model | The vendor's model |
| Can it see your system | Yes — reads, writes, activates through ADT | Yes (cloud/RAP stacks) | Yes — read / write / activate via ADT MCP | ✕No — text in the editor only |
| DDIC objects | Creates tables, structures, data elements, domains | Object creation & RAP generators on cloud-ready stacks; classic DDIC limited on older releases | Partial — depends on release & tool set | ✕None |
| Autonomous run | Yes — read-only + a ship queue with a two-person gate | Agentic via external coding agent (Copilot / Amazon Q); mass ATC-fix agent — no built-in gate or ship queue | Agent-driven; no built-in gate or ship queue | ✕None |
| Roles as a tool boundary | Per-role read / write tool allow-list | ✕ | ✕All-or-nothing | — |
| Two-person gate / ship queue | Irreversible actions queued for human approval | ✕ | ✕ | — |
| Team standards / methodology console | Shared coding standards & roles, centrally managed | ✕ | ✕ | ✕ |
| Central audit log | Server-side, every action logged | ✕Client-side only | ✕Client-side only | ✕ |
| Multi-user server, channel isolation | Shared server, isolated per developer / project | ✕ | ✕Per-laptop, per-developer | ✕ |
| Spec management & versioning | Specs stored & versioned in the app | ✕ | ✕ | ✕ |
| Old ECC / on-prem | Works where SAP's cloud tooling can't reach | S/4 PCE 2021+ only; no ECC / NetWeaver 7.x path | ✕Needs a modern ADT stack | Doesn't touch the system |
| SAP object deletion | Permanently disabled, at the connector level | — | — | — |
Not a bet against SAP's roadmap — a governance layer on top of it.
Makion runs its own SAP connector and MCP, so it reaches ECC and NetWeaver 7.0x–7.5x where SAP's official ADT MCP can't. On systems where the official ADT MCP is available, Makion can use it as an additional tool backend (planned) — staying the layer that adds roles, an approval gate, a central audit log and team standards on top. Whatever SAP ships next, the governance around it is still missing — and that's what Makion is.
Not a text editor. An agent that goes lock → set source → syntax check → activate.
Makion works through the official ADT tools — a broad surface, not a thin slice. It reads everything it needs: object sources and structure, where-used, data via SQL, function modules, message classes and text elements, type hierarchy, package contents, transports, revisions, even runtime dumps and ABAP docs. Then — in a role with write permission — it makes the change: sap_lock → sap_set_source → sap_syntax_check → sap_activate → sap_unlock. It creates new objects — including data dictionary objects (tables, structures, data elements, domains, table types), message classes, text elements and RAP service bindings; runs your quality gates (ATC, ABAP Unit); refactors (extract method, rename, pretty printer); and manages transports. When it is done, it reports exactly what it touched and in which transport.
Every change comes out Clean-ABAP — cleaned automatically, before activation.
Makion ships its own deterministic ABAP cleaner — 45 Clean-ABAP rules: casing, indentation, spacing, alignment and safe modernizations (MOVE…TO → =, CREATE OBJECT → NEW, EQ/NE → =/<> and more). Switch it on and every source the agent writes passes through it before syntax check and activation — so what lands in your system is standard-clean, not just correct. It only ever changes style, never logic. On or off per project, and per task.
45 rules · Clean-ABAP · before activation
Seven roles. Each is a full, written methodology that writes “the right way” to your standards.
In the chat you pick a role for each request. A role is both a full methodology and an access boundary: read-only roles physically receive only SAP read tools and cannot change anything. An admin can override any role or add their own.
Development
Implements a requirement end to end: understand → explore the current state → reuse what exists → plan → lock + set source → syntax check + tests/ATC → activate → report.
A finished, activated change in your approach — not a draft of code.
Architecture
Delivers a solution design, writes no code.
A considered plan before anyone touches the system.
Code review
Reviews against your standards; findings ordered by priority (Critical / Major / Minor) with exact locations and fixes.
A second, independent pass — with no risk the reviewer “accidentally” rewrites something.
Unit tests
Writes/extends ABAP Unit tests; never changes production logic to “force” a test green.
Test coverage without distorting the business logic.
ATC check
Runs the ABAP Test Cockpit, returns findings ordered by priority; fixes only if you explicitly ask.
ATC-standard quality under your control.
Research
Investigates and answers with evidence, can run SQL queries against the data.
Fast, well-founded answers about the system — with no risk to it.
Specification
Turns a client's raw specification into Makion's internal standardized format, cross-checking against the live system.
A chaotic requirement becomes an ordered, testable spec.
Read-only is a tool boundary
Read-only roles can't write at the tool level, not just at the prompt level. An admin can override any role's methodology or add new ones.
“The right way” is your way — you define it, you control it.
“The right way” is not a black box. Your architect writes your team's standards and methodology in plain language in the Methodology console — and every role follows them on every task. Roles bound what the agent may do, standards define how it writes, specs define what it builds. You control all three and can change them at any time.
A chat where every reply is real work in SAP.
Role chosen, methodology applied, steps executed in your system — all visible in an ordinary desktop-app chat.
Standardized from day one — no “we'll agree on style later.”
Roles ship with a written ABAP methodology already in place: reuse first, read before you write, clean ABAP, naming, performance, error handling. You don't have to teach the agent “how we do things” from scratch — a baseline standard is built in, and the team writes in one approach from day one. And when you want your own, the architect sets it in the methodology console.
- Reuse first — the agent looks for an existing solution before writing anything new.
- Read before you write — exploring the current state always comes first.
- Clean ABAP — modern syntax, no obsolete constructs by default.
- Naming and error handling — consistent by default, tunable to your standard.
- Performance — built into the methodology of every write role, not just the review.
Upload the client's raw brief — get an ordered, testable, versioned specification.
The Specification role takes a client's raw document (file or text) and turns it into Makion's internal standardized format: goal, scope, data objects, ordered testable requirements R1..Rn, SAP objects to change, acceptance criteria, open questions.
The key is real versioning: each new version stays the same document with a stable identifier, and Makion automatically adds a “Changes from the previous version” section. You always see exactly what changed in the requirements — and you can hand this ordered spec straight to the autonomous orchestrator.
Give it a spec — the orchestrator breaks it into steps and drives it to a result. Read-only, with a two-person gate.
Hand the orchestrator a task or a spec — it decomposes it and drives the agents step by step to a result. During the run the agent only reads SAP: no writes to the system. Every proposed change goes into a ship queue — with the object, the type (create / modify / activate), the requirement it closes, a rationale and the payload itself. You watch live progress and can hit Stop at any time — because the run is read-only, stopping never leaves SAP half-changed.
The architect describes the team's standards in words and examples — the whole team writes in one approach.
In the Methodology console the architect or admin sets the team's standards in words and examples — exactly how you do things. This is stored and applied to the agent's work, so ten developers on one Makion evolve the system in one consistent approach, not ten different styles. For developers the methodology, rules and knowledge base are read-only; project admins edit them.
Configure the server in plain language — projects, access, roles and standards.
Claude, Gemini, Codex, Kimi. Choose per project — with no vendor lock-in.
Each project runs on its own engine, chosen by the admin. Change your mind — switch the engine, and the next run goes on it (chat history is preserved). No lock-in to a single provider: when a stronger model appears, you simply switch. The engine and its credentials live on your server — nothing goes to the Makion service.
Everything on your server. SAP data and credentials never leave your infrastructure.
You stand up your own backend, database and SAP connection. The SAP connection, the model key and the sign-in credentials are never sent anywhere — no SAP data goes to a third-party SaaS run by Makion. That's exactly why Makion also works where SAP's cloud tooling falls short — on your on-prem systems and old ECC. For teams whose two main objections to AI in SAP are third-party access to the system and data residency, the on-prem architecture removes both.
- Your backend, your database. Deployed on infrastructure you control.
- Keys and credentials are a server-side secret. Never shown to the client.
- No third-party SaaS. SAP data doesn't go to a service run by Makion.
- Works on ECC. Where SAP's cloud tooling can't reach.
Engines, roles, specs, projects, autonomous mode, model sign-in — all in the desktop app.
No digging into config files for every little thing. Engines and role methodology, specs, projects, turning autonomous mode on/off, model sign-in — it's all managed right in the desktop app. Isolation follows the principle channel = one developer × one project: each channel has its own SAP connection, its own workspace and its own history. Several developers comfortably share one Makion instance without mixing systems and sessions.
Edit SAP Adobe Forms by describing the change — not by hand in LiveCycle
Every SAP Adobe Form is still hand-drawn in LiveCycle Designer — slow, error-prone, and no tool does it for you. Makion reads an existing form, applies a structural change (add / remove / reorder / rebind a column) and hands you a paste-ready XDP for the SFP “XML Source” tab. A deterministic engine guarantees the geometry, data bindings and table grid — never “valid XML that renders broken.” Describe the change in plain language and get the file on your PC.
Get your custom ABAP S/4HANA / Clean-Core ready — one object at a time, in dialogue
The move to S/4HANA is unavoidable, and custom code is the #1 cause of migration overruns. Makion takes one object, finds what breaks on S/4HANA itself (deprecated APIs, direct table access, old syntax) and proposes a minimal fix for each — you approve, it applies and activates. For risky changes it writes a pin-down test first. It runs on-prem, on your own ECC — where SAP’s cloud AI can’t reach.
“What if it breaks production?” — It won't. That's built into the design, not into a prompt.
A read-only role physically cannot write. Read tools and write tools are separate sets; read-only roles simply aren't handed the write tools. The boundary is in the code, not a request to the AI to “behave.”
The broker checks every call. Every SAP tool call goes through the connector broker; a call outside the current role's set is rejected there and never reaches SAP. For engines without their own allow-list (Codex, Kimi) this is the main and only gate — and it holds.
SAP object deletion is permanently disabled. sap_delete_object is in no role, and the broker blocks it unconditionally. There is no switch to turn it on.
No write without a human in autonomous mode. A two-step gate: a person approves, and separately a person confirms the apply.
A full audit log. Every tool call (flagged on writes), every connection, error and agent run is recorded and available to the admin.
Everything stays on your infrastructure. Model keys are a server-side secret: injected only into the agent process, never shown to the client and never logged.
Honestly: in an interactive chat a write-permission role (Development, Unit tests, ATC) makes the change during the dialogue you're running — there's no separate “Apply” button here, you steer step by step. The hard guarantees in chat: read-only roles can't write, and deletion is always disabled. If you need a hard button-gate on every write — use autonomous mode with the ship queue.
Makion = make + -ion → “the act of making.”
make — to build, to create. -ion — turns an action into a thing: creation, action, automation. Together it reads literally as “the act of building” — exactly what the product does: it builds ABAP, in your system, to your standards. A short, coined name with no “SAP” or “ABAP” (both trademarks of SAP SE), equally comfortable in EN / DE / UK.
For those who write ABAP and are responsible for a live system.
Indie and freelance developers
ABAP developers and consultants who want to describe a task in words and have Makion carry it out, review it or investigate it in their system.
IT teams at an SAP customer
Several developers need a single instance, isolated by “developer × project”, each with their own SAP connection.
Consulting firms
Who need one development standard across the whole team and work on client on-prem / ECC systems without moving data to the cloud.
Put an AI developer inside your SAP — on your terms.
Your SAP. Your model. Your AI — your key or subscription. Your standards. Makion does the work inside the system — reads, writes, activates, creates DDIC — and guarantees that nothing irreversible happens without your decision.
On-prem. SAP data never leaves your infrastructure.
Interested?
Drop a line — we'll discuss a rollout on your system one on one.