Building Zact AI: An AI Teammate for Meetings

Context

Zact AI started in a very ordinary way. I moved in with two of my former classmates from ALU, Moussa and Chernet. We’d been living together for a while, and we kept circling the same idea. It would be fun to build things on the weekends and see what happens if we ship consistently.

So we did. No grand plan, no “startup energy.” Just shipping and learning in public.

Shipping, as a default

Living together made progress almost inevitable. Ideas came up in random conversations, at the table, in the hallway, late at night. The feedback loop was short enough that we could test a thought the same day.

We started with small developer packages: tools we genuinely wanted, built quickly, then improved through real usage.

The first real signal: nl-shell

One of the early tools we built was nl-shell. The idea was simple: communicate with your terminal in natural language.

We designed it to support multiple model providers (OpenAI, Anthropic, Gemini, DeepSeek, and others) because we didn’t want a dev tool that only worked if you committed to one ecosystem.

Within the first two weeks, it was doing 300+ downloads weekly.

That number isn’t “internet famous,” but it’s the kind of signal that matters when you’re early: strangers choosing to install something you built, and choosing to come back. It gave us the motivation we needed to think bigger.

At that point, Moussa suggested we start working on a larger problem. Something that isn’t just a tool, but a direction.

From dev tools to infrastructure: NuPl

After we saw early adoption, we started asking a broader question: if developers were experimenting with agents everywhere, why did the ecosystem still feel so fragmented and fragile?

We pivoted into another side project called NuPl (“New platform for AI”). The direction was ambitious: infrastructure for DevOps and AI agents. Basically, version control, testing, and observability for LLM agents at scale.

The goal was simple to describe and hard to execute: make agents feel less like magic and more like systems you can reason about. Reliable, measurable, and debuggable.

The belief underneath it

With Moussa, I’ve always shared the same objective: democratize AI agent operations and help create the standard for agent infrastructure.

We believe AI agents shouldn’t be mysterious, fragile, or locked behind technical expertise. They should be observable, reliable, and usable by anyone, the way we expect traditional software systems to be.

That belief kept pulling us forward even when the implementation details kept changing.

The pivot that clarified the real question

NuPl taught us a lot, but it also surfaced a bigger question.

What if we didn’t just build infrastructure for agents? What if we built a system where agents actually help people build and run companies?

That was the moment Zact came into focus. It wasn’t an instant switch; it happened after shipping, learning, and hitting the edges of what we were building. But once the question was clear, the direction became obvious.

Zact became our answer to everything we had learned: from building dev tools, from shipping fast, from watching AI tooling fragment, and from watching founders struggle to turn ideas into structured execution.

What we’re building now

Today, Zact is our attempt to build a world where AI agents are first-class teammates and companies behave more like systems than tool stacks.

More concretely, Zact is an AI teammate that shows up in the place where work often begins and then quietly falls apart: meetings.

Meetings create momentum. Follow-ups lose it. Decisions disappear into chat logs. Action items get fuzzy. Notes end up everywhere. And even when everyone is trying, the thread breaks.

Zact is built to keep that thread intact without being spammy or cringe.

When Zact joins a call, it comes with context. It understands the meeting title, agenda, and who’s in the room. Over time it keeps a running memory of what was decided, what changed, and what matters.

During the meeting, it can help in small, human ways that add up:

It can summarize mid-call when people need to reset. It can ask clarifying questions when an owner or deadline is vague. It can steer the conversation back toward decisions when it’s drifting.

After the meeting, it does the part that usually gets dropped:

It turns talk into execution. It converts decisions into owners and next steps, pushes outcomes into the tools your team already uses, and keeps a history so nothing slips quietly.

In other words, Zact is a full-stack platform for AI meeting assistants that participate in real time and automatically sync outcomes to your workspace.

That’s the standard we’re building toward with Zact: agents that participate in real work, inside real organizations, with real accountability, and with the same reliability and observability we expect from traditional software systems.