Why Axiom Core?
Moving beyond fragile API glue code and maintenance-heavy boilerplate.
In modern application development, the "Glue Code" between the frontend and backend is the primary source of bugs, security leaks, and architectural drift. Axiom Core was built to eliminate this layer entirely by replacing fragile manual implementations with a deterministic, native runtime.
The Problem: The "Non-Deterministic" Gap
Most teams rely on OpenAPI (Swagger) or GraphQL. While these tools are excellent at defining the shape of data (Types), they completely fail to define the behavior of the API (Logic).
Logic Duplication
Every client (iOS, Android, Web) manually implements its own retry logic, caching strategy, and error handling. This leads to 'Feature Parity' nightmares.
Architectural Drift
When a backend field changes from required to optional, or an error status code logic shifts, older mobile clients crash because they aren't 'aware' of the new contract.
Fragile Contracts
Standard JSON schemas are informative but not enforceable. There is no 'Guardian' at the network layer to ensure the contract is actually followed.
The Maintenance Tax of "Fat" CodeGen
Traditional tools solve API integration by generating massive amounts of boilerplate code. However, generated code is still code.
The Hidden Cost of Fat SDKs
Every line of generated network logic, serialization, and error parsing carries a maintenance cost. A typical OpenAPI-generated SDK for a medium-sized project can exceed 5,000+ lines of Dart/Kotlin code.
This increases your "error surface," slows down compilation, and forces your developers to debug code they didn't even write.
The Axiom Solution: Thin SDK + Native Runtime
Axiom Core introduces a Deterministic Behavioral Layer that moves complexity out of your application code and into a pre-compiled native engine.
Fat SDK Approach:
- Generate 5,000 lines of Dart code.
- Manually implement
RetryPolicy. - Manually implement
Diocaching. - Manually handle
try/catchfor every status code. - Risk: High chance of platform-specific bugs.
Thin SDK + Rust Runtime:
- Generate 200 lines of Type-only code.
- Define behavior once in
Acore. - The Native Rust Runtime enforces the policy.
- Result: Zero network boilerplate in your app. Identical behavior on iOS & Android.
Core Pillars
1. Backend as Source of Truth
Instead of maintaining a separate OpenAPI spec or re-writing structures in a configuration file, Axiom introspects your backend code directly. If your Pydantic model changes, your contract changes. No drift, no manual sync.
2. Deterministic Enforcement
With Acore, behaviors like Caching (Stale-while-revalidate, Cache-first) and Retries (Exponential backoff with Jitter) are defined in the contract itself. The client-side runtime executes these instructions natively.
3. Cryptographic Integrity
Every contract pulled from Axiom Cloud is signed. The trust-axiom.json ensures that your app only communicates via a verified, untampered behavioral contract.
Direct Comparison
| Feature | OpenAPI / Swagger | GraphQL | Axiom Core |
|---|---|---|---|
| Typed Models | ✅ | ✅ | ✅ |
| Code Generation | ⚠️ Fat SDK (High Maint) | ⚠️ Fat SDK (High Maint) | 🚀 Thin Layer (Zero Maint) |
| Retry Policies | ❌ Manual | ❌ Manual | ✅ Enforced |
| Caching Strategy | ❌ Manual | ❌ Manual | ✅ Enforced |
| Signed Security | ❌ None | ❌ None | ✅ Cryptographic |
| Runtime Engine | ❌ Application Layer | ❌ Application Layer | ✅ Native Rust |
The Bottom Line: By moving the complexity into a pre-compiled, deterministic Rust runtime, Axiom Core reduces your frontend API logic to a thin, typed interface, drastically lowering the cost of development and the probability of runtime errors.