The problem Synoptic solves

The Problem It Solves

Building on-chain AI agents is still too fragmented. Teams usually have to wire together wallet auth, payments, trade execution, and monitoring across multiple tools and scripts. That makes systems brittle, hard to demo, and risky to operate.

What People Can Use It For

• Running multiple autonomous agents that can execute tasks and interact through APIs.
• Simulating real agent economies (payments, trades, activity) for demos and testing.
• Operating live agent workflows from one dashboard instead of scattered scripts.
• Tracking agent performance, payment status, and execution history in one place.

How It Makes Existing Work Easier and Safer

• One control surface: unified dashboard + API for agent lifecycle, activity, and payments.
• Less custom glue code: built-in auth/session and payment flows reduce integration overhead.
• Safer testing: mock/simulated execution lets teams validate behavior before using real funds.
• Operational visibility: auditable logs and status traces make debugging and incident response faster.
• Faster iteration: teams can spin up and orchestrate many agent behaviors quickly from terminal/automation scripts.

Challenges I ran into

Challenges I ran into

One of the biggest hurdles was with KiteAI Chain’s Facilitator. The piecewise/streamed flow was inconsistent in our setup, so parts of the pipeline would fail or return partial outputs. I worked around this by adding strict retries, timeout guards, and a fallback path so the app could continue even when the facilitator path was unstable.

Another major blocker was the Uniswap Trading API on Monad testnet. Even though Monad support was indicated, routing/quote calls were unreliable and swaps wouldn’t execute end-to-end. I handled this by gating the feature behind a network capability check, adding clearer user-facing errors, and using a fallback swap path for unsupported or unstable routes instead of letting the flow silently fail.

Other issues included:

• RPC instability/rate limits on testnet causing intermittent failures.
• Gas/nonce edge cases leading to stuck or dropped transactions.
• Token metadata mismatches (like decimals/symbol assumptions) causing incorrect quote amounts.

I got through these by building a more defensive integration layer: better logging, network checks before execution, retries with backoff, and fallback logic per dependency. That turned hard failures into predictable, debuggable behavior.

Use of AI tools and agents

We use AI in two layers:

1. In-product AI features that help users complete core tasks such as summarization, extraction, classification, and content generation.
2. Developer AI agents that assist with engineering work like code changes, testing, security review, and documentation.

How they work together:

• Orchestration: A coordinator routes each request to the right model or specialist agent based on task type.
• Specialization: Different agents handle focused jobs such as coding, review, or domain analysis.
• Shared context: Agents use the same project context, policies, and task state so outputs stay consistent.
• Human control: Engineers review important outputs, approve high impact actions, and handle exceptions.
• Safety and quality: Guardrails, validation checks, and test runs are applied before changes are accepted.
• Traceability: Runs are logged with prompts, actions, and results so decisions can be audited.

In practice, this creates a hybrid workflow where AI speeds up execution and humans provide direction, approval, and final accountability.