Applied AI

Agentic systems engineering

Build stateful AI workflows with explicit authority, reliable tools, observable execution, and controlled recovery.

In brief

How do you delegate work without losing control of its execution?

  • Specify which actions the system can read, propose, and execute.
  • Build durable state, typed tools, idempotency, and recoverable failure paths.
  • Measure authorized task completion across the full workflow, including human review.

Make delegated work dependable

An enterprise agent operates inside a business process. It may gather evidence, inspect records, propose an action, or coordinate several services over an extended period. Its usefulness depends on whether that delegated work reaches a valid conclusion with the right permissions and a recoverable execution history.

NYIC engineers agent systems around explicit state, bounded authority, and verifiable tool results. We design the orchestration and the surrounding application together, so a user can understand what the agent has done, what remains unresolved, and where a human decision is required. The architecture supports both interactive assistance and asynchronous workflows that may pause for external events or review.

Define the task and its authority

We start by identifying the smallest meaningful unit of work. A valuation request, a claims exception, and a security investigation have different completion conditions. Each needs a task contract that identifies required evidence, allowable tools, output schemas, resource budgets, and escalation conditions.

Authority is granted separately for reading, proposing, and executing. A workflow may retrieve records automatically while requiring approval to change a case status or send an external communication. These permissions are enforced by backend services using the authenticated user and task context. Model instructions communicate the boundary, while service controls make the boundary effective.

Tool descriptions receive the same engineering attention as public APIs. Inputs need explicit types, units, identifiers, and accepted ranges. Outputs need stable schemas, source timestamps, error categories, and operation identifiers. A model should be able to distinguish a business rejection from a temporary infrastructure failure without guessing from free text.

Build an explicit execution model

A durable workflow records its current state, completed steps, pending operations, selected evidence, and approval history. We use state transitions to express the process and reserve model discretion for decisions that benefit from inference. This makes the system easier to inspect and reduces accidental dependence on an ever-growing conversation transcript.

For a research task, the execution path may include clarification, retrieval, evidence assessment, calculation, synthesis, and review. Each step has an acceptance condition. If a calculation lacks a required input, the workflow returns to evidence collection or requests a user decision. If an approval expires, a later action must obtain fresh authorization.

Parallel agent roles can help examine independent evidence or competing hypotheses. We introduce them where their separate responsibilities improve the task. Their outputs pass through reconciliation rules that preserve disagreement and provenance. Agreement between multiple model-generated answers is insufficient evidence of correctness when all depend on the same incomplete source.

Engineer tools for repeated execution

Distributed workflows encounter interrupted connections, delayed responses, and workers that restart. A write operation therefore needs an idempotency contract. The caller supplies a stable identifier, the service records the result, and a retry returns the existing outcome. This prevents a lost response from becoming a duplicate payment, ticket, or case update.

Retries are bounded and specific to failure type. Authentication failures require intervention. Validation failures require corrected inputs. Temporary service errors may be retried with backoff. Exhausted operations move to an inspectable recovery state with enough context for an operator to continue safely.

Long-running tasks benefit from queues, checkpoints, and explicit deadlines. We design cancellation behavior and compensating actions where a sequence crosses services that cannot share a transaction. Recovery procedures identify which steps can be repeated and which require checking an external system before proceeding.

Connect memory to accountability

Agent memory can include immediate task state, user preferences, and longer-lived institutional knowledge. These stores have different permissions and retention needs. We separate them so a temporary case detail does not silently become a durable instruction or cross into another user’s context.

Stored memories retain provenance and revision information. Users need a way to inspect or correct material that influences future work. Retrieval policies prioritize authoritative records and current task evidence. A remembered assertion cannot bypass a current permission check or substitute for an approved system of record.

Validate the entire trajectory

Evaluation examines tool selection, argument correctness, source support, state transitions, approval compliance, and final output quality. We construct scenarios with unavailable tools, adversarial retrieved text, contradictory records, duplicate requests, and interrupted execution. These tests reveal failures that a final-answer score can conceal.

Operational traces connect a request to model calls, retrieval results, tool invocations, approvals, and external effects. Sensitive values require deliberate logging controls. The goal is enough evidence to reconstruct a decision without turning observability into an uncontrolled copy of confidential information.

Success measures include accepted-task completion, unauthorized-action attempts blocked, recovery success, reviewer intervention, execution time, and cost per completed task. We segment by workflow and failure class so aggregate performance does not hide a fragile integration.

Delivery and handoff

An engagement produces a workflow specification, typed tool adapters, orchestration implementation, access policies, evaluation scenarios, operational dashboards, and recovery runbooks. Early delivery focuses on a bounded workflow with inspectable outcomes. Subsequent expansion adds tools and discretion only after the corresponding controls and evaluations are in place.

Managed platforms and open frameworks can provide useful runtime capabilities. Our implementation choices follow the enterprise environment, deployment constraints, and need for portability. NYIC’s responsibility is to connect those components into a system whose behavior remains understandable throughout execution, including the moments when a tool fails or the evidence cannot support a conclusion.