Scaffy

Design and simulate distributed cloud architectures with AI agents

Comment

Scaffy

Inspiration

Modern software systems are becoming increasingly distributed and complex. Teams today work with microservices, event-driven architectures, queues, cloud infrastructure, serverless functions, and multiple databases across different environments.

However, software architecture is still mostly static.

Architecture diagrams quickly become outdated, infrastructure definitions live separately from documentation, and teams often struggle to visualize how systems behave under real workloads, failures, or scaling scenarios.

We wanted to rethink software architecture as something alive, executable, and collaborative.

That idea became Scaffy: an AI-native platform for designing, simulating, and validating distributed cloud architectures using intelligent agents.

What Scaffy Does

Scaffy allows developers and architects to visually model distributed systems using cloud-native components such as:

  • API Gateways
  • Microservices
  • Databases
  • SQS/SNS
  • Redis
  • Kafka
  • Serverless functions
  • Storage systems
  • Event buses

Each component can be configured with real infrastructure-like settings.

For example:

  • queue retry policies
  • visibility timeouts
  • scaling limits
  • concurrency settings
  • replication strategies
  • caching behaviors

Instead of treating diagrams as static documentation, Scaffy transforms them into executable architecture graphs.

These graphs can then be:

  • simulated
  • validated
  • analyzed by AI agents
  • eventually converted into Infrastructure as Code

Simulation Engine

One of the most interesting parts of the project is the simulation layer.

Instead of trying to emulate real cloud providers entirely, Scaffy focuses on behavioral simulation of distributed systems.

The platform models:

  • request flows
  • event propagation
  • retries
  • dead-letter queues
  • asynchronous communication
  • service bottlenecks
  • failure propagation
  • scaling pressure

For example, a user can simulate a high-volume flow like:

Frontend
→ API Gateway
→ User Service
→ Kafka
→ Notification Service
→ Analytics Service

Scaffy then visualizes:

  • request traces
  • queue growth
  • retry behavior
  • service overload
  • latency hotspots
  • architectural bottlenecks

This creates a “digital twin” of the architecture that developers can interact with before deploying real infrastructure.

AI Agents

Scaffy uses specialized AI agents that collaborate around the architecture graph.

Different agents focus on:

  • scalability
  • resiliency
  • event-driven design
  • infrastructure recommendations
  • architectural validation
  • cost optimization

Instead of generating only diagrams, the agents reason about how systems behave.

For example, the platform may suggest:

  • converting synchronous communication into async workflows
  • adding dead-letter queues
  • introducing caching layers
  • increasing service replication
  • separating bounded contexts

Hybrid Real + Simulated Systems

Another concept explored in Scaffy is hybrid execution.

Some services can be connected to real APIs or real endpoints while the rest of the architecture remains simulated.

This enables:

  • frontend teams to test incomplete systems
  • architecture validation before deployment
  • partial execution of distributed workflows
  • experimentation without provisioning full cloud infrastructure

How We Built It

Scaffy is designed around a graph-based architecture model.

Each infrastructure component becomes a node with:

  • configuration
  • runtime behavior
  • event capabilities
  • communication patterns

Connections between nodes define:

  • synchronous calls
  • asynchronous events
  • queues
  • pub/sub relationships
  • data flow

The simulation engine processes events over time using a distributed event-flow model inspired by discrete event simulation systems.

AI agents analyze the graph continuously and provide architecture-aware recommendations.

Challenges

One of the biggest challenges was defining the right level of abstraction.

We did not want to build a full AWS emulator, because that would introduce massive complexity.

Instead, we focused on simulating the architectural behavior that matters most for system design:

  • retries
  • latency propagation
  • queue pressure
  • concurrency
  • resiliency
  • event flow

Another major challenge was balancing realism with usability.

We wanted Scaffy to remain visual and approachable while still representing meaningful distributed-system behavior.

What We Learned

Building Scaffy taught us that software architecture can evolve beyond static diagrams.

By combining:

  • executable graphs
  • cloud-aware infrastructure modeling
  • AI agents
  • behavioral simulation

we can create systems that help teams reason about architecture before deployment.

We believe the future of software architecture is:

  • interactive
  • executable
  • collaborative
  • AI-assisted

and Scaffy is our first step toward that vision.

Built With

Share this project:

Updates