ECC: A Harness-Native OS for Cross-Language Agent Workflows

If you’ve ever tried to stitch together agents written in Python, JavaScript, and Rust into one smooth workflow, you know it’s a nightmare. Different runtimes, dependency conflicts, and awkward IPC glue code turn a “cool idea” into a time sink.

That’s where ECC comes in. It’s not another framework or library—it’s a harness-native operating system purpose-built for cross-language agent workflows. Think of it less as a tool you run, and more as a lightweight runtime that treats every language as a first-class citizen.

What It Does

ECC lets you define, connect, and orchestrate agents written in different languages in a single, unified environment. Instead of forcing everything into one language or wrestling with Docker containers, ECC acts as the hypervisor for your agents. It manages their lifecycle, handles inter-agent communication, and provides a consistent logging and state model across Python, Node.js, Go, Rust, and more.

You write your agents in whatever language makes sense for the task—data processing in Python, latency-critical loops in Rust, UI in JavaScript—and ECC handles the orchestration. The output is a single, coherent workflow where each agent communicates via shared memory or a lightweight message bus, not through brittle HTTP calls or file-based handoffs.

Why It’s Cool

1. Truly language-agnostic agent orchestration.
Most “cross-language” tools still force you to pick a primary runtime or use heavy serialization (hello, JSON). ECC treats each agent as a native harness process, with zero-copy data sharing between them. That means your Python agent can directly hand a tensor to your Rust agent without serialization overhead.

2. Harness-native design.
ECC isn’t just a process manager—it’s an actual operating system for agents. It provides its own memory management, scheduling primitives, and a lightweight IPC layer that feels like calling a function, not sending a request. This makes agent workflows feel like they’re all running in one language, not ten.

3. Built for real-world agent patterns.
Whether you’re building a multi-step RAG pipeline (Python for embeddings, Go for search, Rust for ranking) or a micro-agent swarm for web scraping, ECC’s native support for fan-out, join, and retry patterns means you don’t need to wrap everything in a custom workflow engine.

4. Zero config for most setups.
You define your agents in a single config file (YAML/TOML), point ECC at it, and it auto-discovers runtimes. No installing separate package managers for each language version.

How to Try It

The easiest way to get started is to clone the repo and run the sample workflow:

git clone https://github.com/affaan-m/ECC.git
cd ECC
cargo run -- example/python_and_rust_agent.yaml

That config connects a Python agent (which fetches data) to a Rust agent (which processes it) in under 30 seconds. Full docs and more examples are in the repo’s examples/ folder.

Want to build your own? Just define an agent per language:

agents:
  - name: data_fetcher
    runtime: python3
    source: "agents/fetcher.py"
  
  - name: processor
    runtime: rust
    source: "agents/processor"
    depends_on: [data_fetcher]

ECC compiles, links, and runs the whole thing as a single harness.

Final Thoughts

ECC solves a real pain: the headache of making agents talk across languages without losing performance or sanity. It’s not trying to be Kubernetes for agents—it’s something smaller, smarter, and more focused. If you’re building anything where different pieces are best written in different languages, give it a spin. It might save you a lot of glue code.

One tip: start with a two-agent workflow (Python + Rust is a killer combo) to feel how seamless the data flow is. Then scale up—ECC handles it.

Check it out on GitHub: github.com/affaan-m/ECC

Follow us at @githubprojects for more dev-friendly tools, repos, and stories from the open source world.