An agent can combine tools to pursue an outcome that does not have its own button in an application. That is the useful idea behind agent-native software: give the system enough context and well-defined operations to plan, act, inspect the result, and adjust.
The engineering work is deciding where that flexibility helps. A weekly summary may need judgment across several sources. Updating a balance or checking access should follow an explicit contract. Both can belong in the same product.
This guide presents design recommendations, not a benchmark or a claim that every Avala workflow has these properties. The November 2026 revision clarifies authorization, recovery, and completion criteria while retaining the original focus on composable tools.
Aim for useful parity within the user's permissions
Suppose a user can create, organize, and tag notes through an interface. They ask an agent to summarize today's work and tag the summary as urgent. If the agent can read notes but cannot save an authorized result, the experience has a gap.
Audit those user journeys explicitly. Equivalent outcomes matter more than mapping every button to a separate tool. But parity does not mean giving the agent every permission the user holds for every task. Scope access to the current work and preserve the application's ownership and approval rules at each entry point.
A useful test includes both a permitted operation and a refusal: can the agent save a summary in the intended workspace, and does the same tool reject a write outside that workspace?
Granularity: tools are primitives, features are outcomes
Small tools can be combined in different ways. A system with list_files, read_file, and a scoped write_file operation can support several review workflows without a separate endpoint for each one.
For example: “Review files modified this week, summarize the changes, and suggest three priorities.” The agent can choose what to inspect and assemble a result. That is a good use of flexible planning.
Not every operation should be decomposed into raw file writes or shell commands. A domain operation such as accepting a dataset release may need validation, an atomic state change, and an audit record. Those requirements belong in the implementation even when an agent chooses when to call it. A prompt is not a substitute for a transaction or an authorization check.
Composability still needs evaluation
Some new experiences can be expressed by changing a prompt over existing tools. Others need new data, permissions, UI, or implementation. Treat a prompt change as a behavioral change: version it and evaluate it against representative tasks before rolling it out.
Use simple workflows where they fit. Anthropic's engineering guide to effective agents distinguishes predefined workflows from systems where a model directs its own tool use, and recommends starting with the simplest approach that meets the need. More autonomy is a design choice with cost and latency tradeoffs, not a quality score by itself.
Emergence: capability you didn't build
An agent that can read notes and task lists may help answer: “Which commitments in my meeting notes are missing from my schedule?” That can reveal demand for a workflow you had not designed explicitly.
Inspect the answer before treating the capability as established. Did it miss a commitment, invent a deadline, or consult a source the user did not authorize? Turn recurring requests into evaluated workflows. A successful demonstration is a useful starting point; repeated performance across relevant cases is stronger evidence.
Add domain tools with explicit contracts
A domain tool should make its inputs, effects, and failure behavior understandable. It can provide:
- Vocabulary: a named operation such as creating a note or validating a release.
- Invariants: checks that remain enforced regardless of which caller invokes the operation.
- Efficiency: a single supported action in place of repeated low-level calls.
- Recovery: a stable operation identifier, a status lookup, and retry behavior appropriate to the operation.
Keep lower-level primitives only where they support an authorized workflow. They must not offer a path around the domain tool's access or integrity checks. MCP's security guidance describes risks involving authorization, token handling, sessions, and local servers. Connecting a tool through a protocol does not establish that its use is authorized or its output trustworthy.
Make state inspectable
Files are useful when people need to inspect, edit, compare, or export an artifact. A clear directory structure can make a small workspace easy to navigate. Databases can be a better fit for concurrent updates, queries, and transactional state. Neither format establishes ownership or portability on its own.
Choose the representation around the work. Record which source version a result used, what changed, and where the authoritative record lives. Keep credentials and private source material out of logs and generated artifacts. A convenient working copy should not quietly become a second, conflicting source of truth.
Preserve enough context to resume correctly
A long task needs more than a growing conversation. Save the accepted objective, constraints, completed actions, verification receipts, and unresolved decisions in durable state that the application can retrieve.
Offer summaries with links to detail so the agent can inspect the relevant source without loading everything at once. A summary is a navigation aid, not proof that all original evidence survived compression. Before continuing a consequential action, recheck the current source and the applicable permission.
Prompts and memory also need ownership and versioning. A retrieved document can contain mistakes or hostile instructions. Its contents should not silently redefine the user's objective, grant permissions, or change the application's policy.
Completion needs evidence
A completion signal tells the application that an agent considers its work finished. It does not establish that the requested outcome is true. Define acceptance independently of that signal.
For a dataset handoff, a plausible filename is insufficient. A useful check might verify that the intended artifact exists, its manifest matches its contents, and a declared downstream loader can read the supported fields. A tool reporting success is one receipt in that chain, not the whole result.
Track task state explicitly: pending, running, waiting for input, completed, or failed. Keep “request accepted,” “job completed,” and “output verified” distinct when the system is asynchronous. Check the status of an existing job before retrying a write after a timeout, and preserve enough state to recover without repeating completed work.
Share artifacts through controlled workspaces
Users should be able to inspect and revise the agent's work. That does not require unrestricted access to the host or to unrelated customer data. A scoped working directory, a reviewable diff, and an explicit export path can provide a shared experience while preserving isolation.
Define how concurrent edits are resolved and how work is restored after failure. Keep an agent's ability to propose a change separate from its ability to publish, delete, spend, or grant access. Those permissions should follow the actual task and the application's rules.
Silent agents feel broken
Show meaningful progress: the current task, completed artifacts, a recoverable failure, or a decision that needs input. Make it possible to stop the work and inspect what has already happened.
Avoid flooding the interface with internal polling, sensitive tool output, or speculative reasoning. A concise status update should help the user understand what changed and what remains uncertain.
Test the whole user journey
Evaluate an outcome the tools should support, including the paths that make it difficult:
- Missing or stale information.
- A denied operation or expired permission.
- An interrupted run and a retry after an ambiguous response.
- Concurrent edits to the same artifact.
- A tool returning partial or incorrect output.
- A result that looks complete but fails the user's acceptance check.
Record the inputs, tool and prompt versions, actual outputs, and why the result passed or failed. Routing, deterministic workflows, and typed validation can all be good design choices. Judge them by the user's outcome, reliability, and total effort rather than by how autonomous the system appears.
Software that pursues outcomes
Composable tools let an agent investigate and adapt. Clear contracts let the application preserve the boundaries that investigation must respect. Evidence connects both to a result someone can rely on.
For Physical AI, that means keeping a proposed label, an accepted dataset, and a verified model improvement distinct. Explore Avala's developer entry points for the supported interfaces, or follow the fleet learning workflow to see how the stages fit together. Evaluate a representative task before expanding the scope.



