Agents Aren't Coworkers: Embedding AI for Calm, Effective Automation

The agentic management software landscape has evolved significantly since early systems like Moltbot and OpenClaw. Today, a competitive field includes ZeroClaw, Hermes, and AutoGPT, offering genuinely helpful generic agent loops. Many companies, including Feldera, are already implementing agents for code review, customer troubleshooting, and infrastructure maintenance.

This practical implementation leads to an interesting philosophical question about the future of human-agent interaction. Mark Weiser's influential article "The Computer for the 21st Century" offers a relevant perspective: "The most profound technologies are those that disappear. They weave themselves into the fabric of everyday life until they are indistinguishable from it."

Weiser envisioned computing that fades into the background, enhances life without constant interaction, minimizes demands on attention, and remains calm, reliable, and predictable. Today's agents—copilots, chatbots—are designed to be human-like, with high explanatory tendencies, text generation, turn-taking requirements, and conversational patterns that mimic human collaboration. This approach creates significant cognitive load for humans who must interact, parse, and manage these conversational agents.

The solution isn't simply creating smarter prompts. Instead, we need software designed to meet agents halfway, ideally within existing applications rather than external agent runners. When given proper interfaces, agents become less conversational and more ambient. They no longer need constant explanation or negotiation, allowing them to stay in the background, react to changes, and make steady progress with minimal supervision—closer to Weiser's vision of calm technology for machines.

Several established design patterns can help create less noisy, more effective agent integration:

1. Command-line interfaces that enable efficient agent-system interaction and reduce token usage
2. Declarative configurations, schemas, and manifests that define desired outcomes rather than specific steps
3. Reconciliation loops (as popularized by Kubernetes) where the target state is declared and the system continuously converges toward it

These patterns enable existing software to integrate better with agentic loops, reducing conversation and increasing convergence toward calm technology for machines.

However, this raises an important question: what other "agentic software patterns" remain undiscovered? One particularly promising area involves the intersection of agents and database engines.

Feldera, a query engine for incremental data processing, already implements several of these patterns: CLI interfaces, SQL for declarative computation descriptions, and a control plane built around desired-state reconciliation. But another critical aspect—how data is presented to agents—is rarely discussed.

Most systems expose tables, dashboards, and CSV exports, forcing agents to poll, diff, and guess changes through expensive queries. Databases can do better through Change Data Capture (CDC), which emits precise updates (inserts, updates, deletes) tied to specific records.

Consider a fraud-detection agent monitoring transactions. In a snapshot model, the agent must periodically scan large payment tables to find suspicious activity—a potentially slow and expensive process. With CDC, the database emits events as they happen: "Transaction T123 inserted: $9,800 from account A to B," "Account A flagged as high risk," "Transaction T123 status updated to pending review." The agent reacts only to these events, avoiding expensive re-evaluation.

For an incremental engine like Feldera, this model is natural. Queries produce streams of changes, not static results, with changes computed incrementally—making even complex questions remarkably cheap to answer.

This approach demonstrates a powerful synergy: agents interpret new information and adapt logic, while engines apply that logic continuously and emit precise updates when changes occur. This division of labor represents a significant step toward truly calm, effective automation that disappears into the background while remaining constantly effective.

The future of agentic systems lies not in making them more human-like, but in making them more machine-friendly—integrating seamlessly with existing software infrastructure to provide ambient, low-cognitive-load assistance that enhances human capabilities without demanding constant attention.