Aster
Machines authenticate to machines, on behalf of users.
Safely — without a central authority and without shared secrets. No DNS, no load balancer, no certificate authority, no OAuth proxy in the middle. Identity is in the connection, not bolted on.
The 2026 example: AI agents calling tools on remote machines without a hosted proxy or shared secrets. The same engineering covers IoT fleets, edge compute, and multi-tenant microservices — anywhere a machine is the principal and the user is the delegating authority.
Built for AI runtimes, edge deployments, sovereign meshes, and multi-language services where addresses are unstable but identity and intent still need to hold.
Python and TypeScript are shipping 0.1.2 as first-class bindings. Go, Java, Kotlin, and .NET are in progress. Rust is planned.
Define services in code. No .proto files. No generation step.
Decorate a class with @service / @Service and its methods with @rpc / @Rpc. Aster scans the type signatures, generates a content-addressed service schema, and handles serialization across languages. Your types are the schema.
from dataclasses import dataclass
from aster.decorators import service, rpc
@dataclass
class HelloRequest:
name: str = ""
@dataclass
class HelloResponse:
message: str = ""
@service
class HelloService:
@rpc
async def say_hello(self, req: HelloRequest) -> HelloResponse:
return HelloResponse(message=f"Hello, {req.name}!")
Browse, inspect, and invoke any service from the shell.
The Aster shell connects to any peer and lets you navigate services like a filesystem. Browse methods, inspect schemas, and invoke RPCs interactively without pausing to generate or vendor client stubs.
Tab completion, streaming output, session subshells, and non-interactive CLI equivalents for scripting.
$ aster shell <endpoint-addr>
producer:/$ cd services/HelloService
producer:/services/HelloService$ ls
Method Pattern Signature
say_hello unary (HelloRequest) -> HelloResponse
producer:/services/HelloService$ ./say_hello name="World"
-> HelloService.say_hello(name='World')
(42ms)
{
"message": "Hello, World!"
}
Connect any AI agent to your services in one command.
aster mcp runs an MCP server that exposes your services as tools with full type information. No OpenAPI mirror, no REST gateway, no SDK assembly line. The service schema is the tool definition.
Layer in credential filters, allow/deny patterns, and human confirmation without splitting your operational surface across another stack.
# Expose your service to Claude or any MCP-compatible agent
$ aster mcp <endpoint-addr>
# The agent sees typed tools automatically:
# HelloService:say_hello
# - name (string, required)
# - greeting (string, default: "Hello")
#
# FileStore:list (server_stream, returns array)
# FileStore:upload (client_stream, accepts _items array)
Make the transport, typed schema, and tool surface feel like one system.
Aster is strongest when the network is messy, the service graph is alive, and your team refuses to accept a pile of adapters as architecture.
Transport, serialization, and schemas are separable in theory and coherent in practice.
You can reason about each layer independently, but the developer experience still feels singular from service definition to peer invocation.
Identity-first connectivity, NAT-tolerant reachability, real-world networks.
High-performance cross-platform payloads, including row-oriented modes for data-heavy workloads.
Code-first services and content-addressed contract identity.
Pick a language, define a service, and see the network shape around it.
The fastest way to feel Aster is to stand up a small service, dial it from another runtime, and inspect it from the shell or an MCP client.