AIOA spArkHAT

• 

• 

Inspiration

AIOA began from a very human source of inspiration: love.

I started building it while thinking about a simple question: if AI becomes increasingly capable and autonomous, how do we make sure that the human being on the other side never becomes irrelevant?

That question gradually turned into an engineering project.

Nature provided some of the strongest metaphors for the architecture.

One was oceanic diel vertical migration — the enormous daily movement of marine organisms between different layers of the ocean. There is no single central controller. Each organism reacts to light, risk, energy, depth and changing environmental conditions, yet together they create a coordinated system.

Another inspiration was the ant colony. Individual ants operate through simple local rules, but collectively they form a resilient and adaptive network with feedback, redundancy and distributed coordination.

AIOA takes inspiration from those patterns: complex AI behaviour should emerge from bounded actions, explicit state transitions, feedback, verification and clear authority boundaries, rather than from giving one model unlimited control.

More recently, this philosophy evolved into Non-Zero (NZ).

For us, Non-Zero does not simply mean a mathematical value other than zero.

It means:

No silent state. No invisible authority. No untraceable action.

If something fails, the system should know that it failed. If an action requires approval, that approval should be explicit. If a model produces a result, its provenance should remain traceable. If execution stops, the system should be able to explain where and why.

AIOA began with love, but it gradually became a technical attempt to build AI systems that preserve human agency.

What it does

AIOA spArkHAT is an open-source control architecture for AI agents focused on bounded autonomy, human approval and auditable execution.

The goal is not to prevent an agent from working independently.

The goal is to let the agent do as much useful work as possible while recognizing the point at which a meaningful human decision is required.

An AIOA-controlled agent can:

perform bounded autonomous work; collect information and evidence; prepare proposed actions; preserve provenance and execution traces; operate within explicit budgets and limits; stop at defined authority boundaries; request human approval before selected high-impact actions; continue execution only after the required decision; fail safely instead of silently; preserve enough state to make recovery and auditing possible.

The core idea is simple:

Let the agent work. Bring the human back when the decision actually matters.

How we built it

AIOA did not begin as a hackathon-only prototype.

It has been developed incrementally as an open-source architecture around a deterministic control layer surrounding probabilistic AI models.

Instead of allowing the model output itself to become authority, AIOA separates model reasoning from execution authority.

The architecture has been developed around concepts including:

explicit action proposals; human approval gates; bounded agent execution; provenance and traceability; typed system states; deterministic control logic around probabilistic model outputs; checkpointing and recovery; idempotent execution concepts; fail-safe behaviour; Non-Zero state integrity.

Previous AIOA work has also been tested in practical agent workflows and cloud-backed demonstrations, which gave us experience with persistent state, memory, verification and human-visible execution.

For Agents for Humans, we are extending this existing foundation into a dedicated hackathon implementation using the Strands Agents SDK and AWS services.

The hackathon layer is designed to demonstrate how an autonomous agent can work normally until it encounters an action that crosses a defined authority boundary. At that point, execution becomes an explicit proposal presented to the human instead of an invisible autonomous action.

The human decision becomes part of the execution record rather than an external afterthought.

Challenges we ran into

One of the hardest problems is deciding where autonomy should end.

If an agent asks the human for permission for every small step, it stops being useful.

If it never asks, human oversight becomes meaningless.

Finding the correct boundary between autonomous work and human authority is therefore one of the central design challenges.

Another problem is ambiguity.

AI systems often tolerate states such as "null", "None", partial completion or loosely defined status strings. In a safety-oriented control system, those ambiguous states can become dangerous because it may be unclear whether something failed, succeeded, disappeared or was never executed.

That challenge directly motivated the Non-Zero direction.

We are also dealing with practical engineering problems such as:

preserving state across interrupted execution; preventing accidental repeated actions; validating model-generated structured output; tracing a decision across multiple agent steps; keeping execution bounded by time, iterations or other budgets; separating model capability from execution permission; designing approval flows that are strong without becoming frustrating.

The broader challenge is that probabilistic intelligence has to coexist with deterministic system guarantees.

Accomplishments that we're proud of

The accomplishment we are most proud of is that AIOA has grown beyond an idea into a working open-source engineering program with a clear architectural direction.

The project now has:

a functioning deterministic control foundation; explicit human-approval concepts; provenance-aware execution; bounded agent-control patterns; reproducible tests; practical AI-agent demonstrations; cloud-backed experimentation; a growing Non-Zero architecture for eliminating silent and ambiguous states.

AIOA has also been used as the foundation for previous experimental demonstrations involving agent memory, evidence verification and controlled AI workflows.

Most importantly, the project has remained focused on one principle:

model capability should never automatically equal authority.

For this hackathon, we are proud to be turning that principle into a concrete Agents for Humans workflow rather than treating human interaction as a cosmetic UI feature.

What we learned

The biggest lesson from building AIOA is that safer AI does not always require a smarter model.

A large amount of safety can come from the architecture around the model.

A model can remain probabilistic while the surrounding system defines deterministic rules for:

what the model is allowed to propose; what it is allowed to execute; when the human must intervene; how state is represented; how actions are traced; how failures are recovered; how repeated execution is prevented.

We also learned that human-in-the-loop design works best when the human is not constantly interrupting the agent.

Human involvement should be meaningful rather than frequent.

Another major lesson came from Non-Zero:

an unknown state is not the same as a failed state, a failed state is not the same as a rejected state, and a missing result should never silently become a successful result.

Making those differences explicit dramatically improves the ability to understand and control an agent.

What's next for AIOA spArkHAT

The immediate goal is to complete the dedicated Agents for Humans implementation and connect the AIOA control model cleanly with the Strands Agents SDK and AWS.

After that, the next stage is deeper integration of the Non-Zero architecture:

stronger typed execution states; global trace and correlation IDs; persistent checkpoints; deterministic recovery; idempotency guarantees; validated model I/O; explicit execution budgets; stronger capability boundaries; improved human-approval UX; richer provenance and audit trails.

Longer term, AIOA is intended to become a reusable open-source layer that can sit between increasingly capable AI agents and the real systems those agents interact with.

The vision is not to remove autonomy.

It is to make autonomy bounded, observable, recoverable and accountable.

AIOA started with love, took inspiration from oceans and ant colonies, and evolved through Non-Zero into a simple long-term principle:

AI should become more capable without making the human less important.

Public contact

LinkedIn — Łukasz Żuchowski: https://www.linkedin.com/in/łukasz-żuchowski-807160316/

Built With

• agents
• amazon
• amazon-web-services
• bedrock
• docker
• fastapi
• github
• nz
• python
• sdk
• strands