Object-as-a-Service (OaaS) Overview

• Object-as-a-Service (OaaS) is a cloud abstraction that treats objects as first-class invocable entities by bundling code, state, and non-functional requirements.
• OaaS platforms like Oparaca integrate serverless programming with object-oriented design to automate resource management, workflow orchestration, and SLA enforcement.
• OaaS facilitates efficient scaling and edge integration by leveraging immutable state, tiered storage, and locality-aware scheduling for practical cloud service delivery.

Object-as-a-Service (OaaS) is a principled abstraction layer in cloud computing and networking that treats data-bearing, behavior-rich “objects” as first-class, invocable cloud entities. It synthesizes serverless programming with object-oriented concepts—not only bundling code and state, but also supporting declarative non-functional requirements such as quality-of-service (QoS) and deployment constraints. OaaS is realized by platforms such as Oparaca, which encapsulate logic, data, and QoS into single deployment artifacts, automating resource management, workflow orchestration, state consistency, and scalability across both core cloud and edge deployments (Lertpongrujikorn et al., 2022, &&&1&&&, Lertpongrujikorn et al., 2024, Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025).

1. Formal Definition, Motivation, and Historical Context

OaaS originated as a response to the limitations of Function-as-a-Service (FaaS) and traditional serverless platforms, which, while abstracting resource management, remain stateless and force developers to hand-craft workflow composition, state management, and QoS enforcement via disparate external services and ad hoc glue code (Lertpongrujikorn et al., 2022, Lertpongrujikorn et al., 2024). In OaaS, each "cloud object" is a composite encapsulation of:

• Methods: Invocable functions implementing object behavior.
• State: Structured (key-value, JSON) or unstructured (blobs) data, co-located with method logic.
• Non-functional requirements: Explicitly declared in machine-readable form (e.g., throughput, latency, availability, budget, locality, consistency, jurisdiction).

Formally, an OaaS object is modeled as a 4-tuple:

$O = \langle id, C, S, M \rangle$

where $id$ is a unique identifier, $C$ is the class template (defining state and function signatures), $S$ is state, and $M = \{m_1, ..., m_k\}$ is the set of bound methods (Lertpongrujikorn et al., 2022). Invocation is typically immutable and produces a new object version, promoting consistency, reproducibility, and parallelism.

The motivation behind OaaS draws on several practitioner and empirical studies documenting developer frustration with fragmented abstraction layers and the heavy burden of non-trivial cloud-native development (Lertpongrujikorn, 27 Dec 2025). OaaS is also theoretically anticipated by object-oriented networking (OON), which generalizes OaaS to the network layer, exposing all data and services as natively discoverable and invocable objects using expressive attribute-based naming and method calls at the network layer (Georgatsos et al., 2015).

2. System Architecture and Operational Model

OaaS platforms, notably Oparaca, are commonly built atop Kubernetes and compose several microservices to realize object lifecycle management, method execution, data management, and runtime policy enforcement (Lertpongrujikorn et al., 2022, Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025). Typical architectural components include:

• Package/Class Manager: Parses and validates YAML/JSON class definitions that specify attributes, methods (with container images or code references), inheritance, and non-functional requirements (Lertpongrujikorn et al., 2024).
• Class Runtime and Template Library: Instantiates execution environments matching declared QoS/properties using a library of runtime templates optimized for various SLAs (examples: LTAG for latency, throughput, availability guarantees) (Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025).
• Object Module/Invoker Cluster: Implements distributed in-memory state caching (e.g., IMDG), assigns method calls (sync/async) to appropriate containers, and manages state localization and concurrency semantics (Lertpongrujikorn et al., 2024).
• FaaS Engine: Executes user code in a runtime-agnostic manner (e.g., Knative, OpenWhisk, Fission, webAssembly runtimes) with transparent support for versioning and dataflow orchestration (Lertpongrujikorn, 27 Dec 2025).
• Data Management Module: Handles tiered storage—structured (e.g., ArangoDB) and unstructured (e.g., MinIO, S3-compatible blobs)—with presigned-URL redirection for large objects and two-phase commit for consistent state updates.
• Monitoring, Autoscaling, and Enforcement System: Monitors actual metrics and dynamically adjusts container counts, cache, replica placement, and scheduling to honor developer-declared SLA targets (Lertpongrujikorn et al., 2024, Lertpongrujikorn et al., 2024).

Object invocation and dataflow orchestration follow automated routing: a single API endpoint forwards calls through consistent-hash-based selection, handling parallelism and synchronization in platform logic rather than user code.

3. Programming Model, Dataflow Semantics, and Interfaces

OaaS programming exposes a declarative interface analogous to object-oriented class definitions, extended to integrate QoS and workflow constructs (Lertpongrujikorn et al., 2024, Lertpongrujikorn et al., 2024). Developers author class definitions specifying:

• Attributes: Typed state with access modifiers (PUBLIC/PRIVATE), supporting complex structured and unstructured data.
• Functions: Methods (TASK), dataflow macros (MACRO), and built-in CRUD operations, each mapping to containerized implementations.
• Inheritance: Classes can extend other classes, inheriting methods and attributes with support for overriding public methods.
• QoS and Constraints: Throughput (rps), availability (%), persistence, consistency (eventual, linearizable), budget (cost), locality (e.g., region, edge/cloud), and more (Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025).

Sample YAML interface:

classes: - name: Image qos: throughput: 100 availability: 99.9 constraint: persistent: true functions: - name: resize image: img/resize:latest - name: detectObject image: img/detect-object:latest

Macro (dataflow) methods allow developers to describe DAGs of method calls, supporting parallelism and explicit or implicit data dependencies. The runtime builds invocation graphs and orchestrates execution without developer-managed event chaining (Lertpongrujikorn et al., 2022, Lertpongrujikorn et al., 2024).

API primitives typically include:

• CreateObject(cls, initArgs)
• InvokeSync(OID, method, args)
• InvokeAsync(OID, method, args)
• ExecuteDataflow(OID, macro_name, args)
• Monitoring/readiness checks.

Interfaces are cloud/provider agnostic, supporting deployment across public cloud, on-prem, and edge environments via unified APIs and S3-compatible object storage semantics (Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025).

4. Built-in Optimization, Consistency, and Non-functional Enforcement

OaaS platforms structurally integrate several optimization mechanisms:

• Locality-aware Scheduling: Compute is dispatched to nodes where state resides, reducing data transfer and IO latency; presigned-URL redirection bypasses orchestration for large blobs (Lertpongrujikorn et al., 2022).
• Tiered Storage and Caching: Hot attributes in-memory; cold data on distributed KV or blob stores; batch write-back for throughput; IMDG eviction and cache placement tuned for object access patterns (Lertpongrujikorn et al., 2024).
• Consistency and Fault Tolerance: Updates to both structured and unstructured state use two-phase versioning; write is committed only if both DB and blob write succeed. Exactly-once semantics enforced via message broker offset tracking and idempotent dispatch (Lertpongrujikorn et al., 2024).
• Immutable State and Concurrent Reads: Each method invocation typically yields a new state version (immutability), allowing unlimited parallel reads and conflict-free execution for stateless or idempotent tasks.
• Software Reuse via OOP Features: Inheritance, access control, and polymorphism directly extend modularity and minimize duplication in multi-tenant or hierarchical cloud services (Lertpongrujikorn et al., 2024).
• Declarative SLA/QoS Guarantee: Class runtime templates enforce declared NFRs: throughput enforced by warm-container pre-provisioning; availability by dynamic replica placement, $N = 1 - (1 - P)^A$, with $P$ node stability and $A$ desired availability; consistency (read-your-write, strong, bounded) determined by selected protocol (local reads, Raft, CRDT) (Lertpongrujikorn et al., 2024, Lertpongrujikorn, 27 Dec 2025).
• Adaptation Loops: Live monitoring detects metric violations and takes action (autoscale, reschedule, reallocate), ensuring real-time SLA compliance without developer intervention.

Table: Example OaaS Non-Functional Requirement Parameters

Parameter	Type	Description
throughput	int (rps)	Minimum invocations/sec
availability	float (%)	% uptime required
consistency	enum	none, RYW, bounded, strong
locality	enum	local, any
budget	int ($)</td> <td>Max spend</td> </tr> <tr> <td>persistence</td> <td>bool</td> <td>Persistent state required</td> </tr> </tbody></table></div><h2 class='paper-heading' id='comparative-analysis-evaluation-and-empirical-results'>5. Comparative Analysis, Evaluation, and Empirical Results</h2> <p>Empirical studies and evaluations benchmark OaaS platforms (notably Oparaca) against modern serverless and database abstractions including Knative, OpenWhisk, Flink StateFun, and FaaS+manual storage (<a href="/papers/2206.05361" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Lertpongrujikorn et al., 2022</a>, <a href="/papers/2410.16569" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Lertpongrujikorn et al., 2024</a>, <a href="/papers/2512.22534" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Lertpongrujikorn, 27 Dec 2025</a>). Metrics and workflows evaluated include video transcoding (CPU-bound), text concat (I/O-bound), JSON updates (CPU+I/O mix), and complex DAG-based pipelines (e.g., face detection).</p> <ul> <li><strong>Overhead</strong>: OaaS imposes negligible extra latency (&lt;10 ms for structured-only objects, &lt;5% overhead for large blobs due to presigned URLs); for large text files, HTTP redirect saves ~24% latency. OaaS matches or beats OpenWhisk, trailing StateFun by ~10 ms per call for some workloads (<a href="/papers/2206.05361" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Lertpongrujikorn et al., 2022</a>, <a href="/papers/2408.04898" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Lertpongrujikorn et al., 2024</a>).</li> <li><strong>Scalability</strong>: Nearly linear throughput speedup until bottlenecked by storage backend; e.g., $S(p) \approx 1.8\times$at$p=6$nodes, near-ideal up to$p=12$ (Lertpongrujikorn et al., 2022). Reliability: Raising availability target from 99%→99.999% (1000× gain) costs only 2.5× more resources, delivering 50× reliability gain versus basic serverless SLA (Lertpongrujikorn et al., 2024). Productivity: Developer effort cut by >50% as all dataflow and state wiring vanish from user code; one-shot QoS declaration replaces several rounds of manual refinements, delivering up to 60× performance boost and 50× reliability improvement in end-to-end cloud pipelines (Lertpongrujikorn et al., 2024). Edge Integration: The EdgeWeaver extension achieves 31% faster developer task completion and a 44.5% reduction in lines of code compared to FaaS, supporting cross-edge/cloud transfer and latency/jurisdiction-aware placement (Lertpongrujikorn, 27 Dec 2025). Common baselines lacked either encapsulation, transparent workflow/dataflow, or could not guarantee declared QoS in a unified model. OaaS uniquely provides not just object-orientation atop serverless but also provider-agnostic, SLA-driven deployment (Lertpongrujikorn et al., 2022, Lertpongrujikorn et al., 2024). 6. Variants and Network-/Physical-Layer Extensions OaaS generalizes to other domains by mapping “objects” to device- or network-level resources: Object-Oriented Networking (OON) treats content, devices, and people as network-layer objects, enabling attribute-based naming and method invocation as native network operations (rather than at the application layer), supporting complex discovery, dynamic service composition, and protocol-free interactions (Georgatsos et al., 2015). OON distinguishes informational (attribute/method) and physical (deployment) forms, with scalable lexicographic partitioning and hierarchical p-name routing. Physical Object Virtualization / Robots-as-a-Service applies OaaS to IoT and robotics contexts, virtualizing heterogeneous robots as service objects with SenML-based unified descriptors, publish/subscribe discovery, REST-based federation, and coalition-based assignment, validating the approach in search-and-rescue case studies (Mouradian et al., 2017). 7. Current Limitations and Future Research Directions Current OaaS implementations support a core set of non-functional requirements; richer models for consistency, cost, carbon footprint, and fine-grained policy composition are emerging (Lertpongrujikorn et al., 2024). Current deployments focus on intra-region clusters; multi-datacenter geo-distribution and cross-cloud transactional guarantees remain open. Security, observability, and compliance for enterprise adoption are active research and commercialization areas (Lertpongrujikorn, 27 Dec 2025). Advanced platforms plan specialized runtimes (e.g., to enable ultra–low-latency/edge inference via WASM), adaptive scheduling for data-intensive analytics, and transactional guarantees for complex workflows. OaaS represents a substantive shift from “narrow” function packaging toward self-describing, QoS-driven, dataflow-native objects, providing a verifiable basis for holistic automation of cloud-native development and operations across the core-to-edge continuum (Lertpongrujikorn et al., 2022, Lertpongrujikorn, 27 Dec 2025). Sponsor Organize your preprints, BibTeX, and PDFs with Paperpile. Get 30 days free Whiteboard Generate a whiteboard explanation of this topic. Topic to Video (Beta) Generate a video overview of this topic. Follow Topic Get notified by email when new papers are published related to Object-as-a-Service (OaaS). Continue Learning How does OaaS address the limitations of traditional serverless and FaaS models? What are the key components and architectural modules in an OaaS platform like Oparaca? How does the integration of QoS guarantees enhance the deployment and performance of OaaS objects? What challenges exist in achieving consistency and fault tolerance in OaaS implementations? Find recent papers about Object-as-a-Service (OaaS). Related Topics OpenAPI Specifications Overview FaaS: Functions as a Service Agent-as-a-Service (AaaS) Overview OPC UA: A Standard for Industrial Communication In-Memory Named Object Management Object-Centric Process Mining FaaS Computing: Principles & Applications Dynamic Orchestration Reflector Oparaca Prototype: Cloud-Only Baseline EdgeWeaver: Unified OaaS-IoT Framework Content Overview References Whiteboard Topic to Video Follow Topic Continue Learning Related Topics Stay informed about trending AI/ML papers: About Updates Chrome Extension Paper Prompts Sponsorship API Terms Privacy RSS Contact Twitter Discord Don't miss out on important new AI/ML research See which papers are being discussed right now on X, Reddit, and more: Explore Trending Papers “Emergent Mind helps me see which AI papers have caught fire online.” Philip Creator, AI Explained on YouTube