Itara

Distributed system topology as an explicit, executable layer

Every distributed system has a topology. Today, that topology is an accident of implementation. Itara makes it an explicit architectural artifact.

Itara overview

The Problem

Modern distributed systems become increasingly difficult to evolve.

Communication topology is scattered across application code, configuration and infrastructure. As systems grow, architectural drift accumulates, communication becomes harder to understand, and changes become increasingly risky because the information required to make good architectural decisions is incomplete or unreliable.

Changing service boundaries, transports or deployment granularity often requires coordinated changes across multiple applications, lengthy migration ceremonies and significant operational risk.

The Insight

Infrastructure-as-Code changed how infrastructure is managed.

Kubernetes changed how deployments are managed.

Both introduced declarative layers that became the source of truth for a specific concern.

Itara applies the same idea to communication topology.

Instead of every application defining its own communication, applications execute a declared topology.

Communication topology becomes a first-class architectural artifact that can be versioned, validated, reviewed, governed and automated.

What Itara Enables

  • Architectural experimentation before committing to an implementation
  • Changing service boundaries without rewriting business logic
  • Explicit, reliable topology information
  • Separation of business logic from communication concerns
  • Structural observability of distributed systems
  • Topology validation and governance
  • Increasingly automated architectural evolution

Current Status

Itara is in active development.

The core concepts have been specified and a working reference implementation already exists. The project currently demonstrates:

  • Declarative topology specification
  • Java wiring agent
  • Rust proof-of-concept wiring agent
  • HTTP and Kafka transports
  • Structural observability through OpenTelemetry
  • A complete demo application showing topology evolution without business code changes

Current development is focused on making service colocation practical for real systems by improving isolation within the same JVM, reducing dependency conflicts and simplifying adoption.

Alongside the open core, I’m designing the first generation of tooling that builds on explicit topology rather than implementation details.

Design Principles

Itara is built around a few principles that guide every design decision:

  • Business logic should not define communication topology.
  • Architectural intent should be explicit rather than reconstructed.
  • The declared topology should be the single source of truth.
  • The wiring layer should execute the topology, not make architectural decisions.

Long-term Vision

The wiring agent is only one part of the system.

Making communication topology explicit transforms it from an implementation detail into a first-class architectural artifact. Once topology becomes explicit, reliable and executable, entirely new capabilities become possible.

These include:

  • Visual topology editing
  • Policy validation and architectural governance
  • Topology drift detection
  • Automated topology optimization
  • Automated migration workflows

Just as Infrastructure-as-Code fundamentally changed how infrastructure evolves, I believe communication topology should become a first-class architectural concern with its own ecosystem of tools.

Open Core

Itara is a specification-driven project.

The specification defines the behavior of the topology layer independently of any particular implementation. The wiring agents are implementations of that specification, allowing the ecosystem to evolve without tying the architecture to a single language or codebase.

The specification and the reference wiring agents are open source.

I believe the foundation should be transparent, inspectable and community-driven. Developers adopting Itara should be able to understand exactly how topology is interpreted and executed.

Commercial development focuses on tooling built around the open core. These tools reduce adoption friction, automate architectural workflows and provide enterprise capabilities while remaining fully compatible with the open specification.

Explore the Project

Looking For

I’m currently looking for:

  • Pilot customers
  • Investor conversations
  • Feedback from experienced software architects

If you’re working on large distributed systems and this resonates with you, I’d love to hear from you.