Web App Agents

Your product, with a built-in agent.

Faustine reads your application’s code and builds an agent that knows how to use it. One line of code puts it in your product, working for every user, as that user.

Book a demo How it works
app.northlight.io/today
Good morning, Dana

Tuesday · 5 open deals · 2 tasks due

DealValue
Acme Corpfocus$48,000
Borealis Health$22,500
Chronos Labs$9,800
Delta FreightfocusCall · Thu 10:00$61,000
Ember Analytics$12,400
Faustine AgentLIVE
What should I focus on today?

Start with Acme — the $48k renewal stalls Friday. Delta Freight is waiting on your quote. Both flagged.

Book a call with Delta Freight

Booked — Thursday 10:00with Delta's ops lead. The invite is on your calendar.

Ask anything about this page…
What your users get

An agent that operates your product.

It navigates your screens, calls your actions and works with your data, then combines that with reasoning and web search to finish the job the way a capable colleague would.

Ask once, done in seconds

What used to take four screens and a dozen clicks becomes one sentence, carried out in your product in seconds.

Everything your product can do

Every action your app implements is on offer, including the ones buried three menus deep that your power users love and everyone else misses.

Adoption where it matters

New users get productive on day one, and the features you shipped last quarter finally get used.

How it works

Built from your code. Run in your user’s browser.

Two moments worth separating, because they answer different questions. One happens once, in your pipeline. The other happens on every request, in the page your user already has open.

Build timeOnce at setup, then again on every push
YoursYour repositoryConnected read-only, at the branch you choose.
FaustineCode analysisA pipeline of AI agents reads the app and derives its modules, actions, routing and auth.
FaustineGenerated toolsOne readable, editable, versioned tool for every action it found.
YouReview and publishApprove what goes live, freeze a version, promote it to an environment.
Run timeInside the browser tab your user already has open
Your userAsks for an outcomeIn the widget you embedded, in the middle of their work.
FaustineThe agentPicks the right tools for the request and plans the sequence.
In the pageThe tools runExecuted client-side against your app, carrying the user's own session and permissions.
YoursYour app respondsYour screens and your API, exactly as they behave for that person today.
Underneath, on every callGovernance the platform provides for you
Session and permissions
Versions and environments
Quotas and limits
Logs on both sides

This is the part that makes a security review short. Because the tools run in the page as the signed-in user, the agent operates within the boundary your product already defines. Your existing authorization stays the authorization model.

The process

Five stages. Today, not next quarter.

Launch without building an AI team or maintaining the agent infrastructure yourself. Connect your repo and watch the agent assemble itself.

  1. Connect~30 seconds

    Point Faustine at your code.

    Connect your code repository — any git provider works. From here, Faustine keeps the agent in sync with your code.

    • Any git provider
    • Monorepos supported
    • Stays current on every push
    connect · repository
    GitHubGitLabBitbucketZIP
    acme/crmmaincloning
    • src/app/
    • modules/customers/
    • modules/checkout/
    • auth/session.ts
    • routes.tsx
  2. Analyze~2 hours

    It learns what your app actually does.

    Faustine analyzes your codebase and discovers what your app can do — its modules, its actions, how it authenticates.

    • Modules and actions, from real code
    • Auth and routing, detected
    • You choose the scope
    agent · analysis
    architecturemodulesinsights
    scope: 3 modules · 2 insights

    Modules discovered

    • Customers4 actions
    • Checkout3 actions
    • Dashboard5 actions
    Auth
    JWT · localStorage
    Routing
    React Router · 14
  3. Generate~30 minutes

    Every action becomes an inspectable tool.

    Every action becomes a tool the agent can call. Open any of them, read it, edit it: it is real code with a real contract.

    • One tool per real action
    • Readable, editable, versioned
    • Drafts never touch what's serving
    agent · tools
    Generated tools12 · all editable
    • createCustomer()
      ← Customers · Create customer
    • updateCustomer()
      ← Customers · Update customer
    • refundOrder()
      ← Checkout · Refund order
    • openDashboard()
      ← Dashboard · View revenue

    every tool maps to real behaviour in your code

  4. Integrate~1 minute

    One line of code in your app.

    Paste a script tag into your index file. That's the whole integration — no SDK to learn, no backend to change, nothing to rebuild when the agent evolves.

    • A single script tag
    • No backend changes
    • Runs on your own domain and auth
    index.html
    1. 1<head>
    2. 2 <title>Acme CRM</title>
    3. 3 <script src="https://webagent.faustine.ai/embed?wid=acme-crm" async></script>
    4. 4</head>
    one line · no backend changes installed
  5. ShipInstant

    Your app is AI-Native.

    Publish, and the agent operates your app for real users — with governance, limits, and logging already underneath.

    • It operates, and it answers
    • Swap models anytime
    • Every call logged
    agent · live
    Refund order #1042
    refundOrder(1042)

    Refunded $128.00 to Ana Ruiz. The order is now marked refunded.

    published v1 · governed, logged, rate-limited live

Repo to working agent: the same day

Anatomy

Open all the way down.

An agent is a set of real tools, each one derived from an action your code already implements, and each one open for you to read and change.

1Modules

The feature sets Faustine finds in your repo.

  • Customers
  • Checkout
  • Dashboard
2Actions

What a real user can do inside each module.

  • Create customer
  • Update customer
  • Refund order
  • View revenue
3Agent tools

One inspectable tool per action. This is the agent.

  • createCustomer()
  • updateCustomer()
  • refundOrder()
  • openDashboard()

Readable

Open any tool and see exactly what it will call.

Editable

An IDE-grade editor, your cloned repo read-only beside it.

Versioned

Drafts and published versions. Serving is never mutated by accident.

In the console

Everything the agent can do, open in front of you.

Read a tool, edit it by hand or by describing the change, test it against a real conversation, and publish when it is right.

app.faustine.ai/tools
Every generated capability is real code with a documented contract. Open it, change it, version it.
app.faustine.ai/conversations
Every turn, every tool call, both sides of every request, with latency broken down.
After you ship

It gets better on its own. And you can push it further.

Two things happen the day after launch: your code moves, and you start wanting the agent to reach further than your codebase. Both are already handled.

Always current

You change the code. The agent updates itself.

Faustine re-analyzes on every push. If a change breaks a tool, it's flagged with a proposed fix — you accept it with one click. The agent never falls behind your app.

  • Re-analyzes on every push
  • Stale tools flagged
  • One-click fixes
  • Serving stays exactly as it was
agent · sync
git push2 commits · main

re-analyzing · automatic on every push

detected change · authentication
localStorage JWThttpOnly cookie

Authentication tool

out of date · 1 stale

Update tool
draft v14 · published v13 serving unaffected
Beyond the codebase

Teach it what lives beyond your codebase.

Some capabilities live outside your repo: an internal service, a partner's API, a system older than the team. Write those tools by hand and the agent treats them exactly like the generated ones, with the same governance, versioning and logging.

  • Write tools by hand
  • Call any API
  • Connect MCP servers
  • Same governance as generated tools
agent · tools
Tools+ Add tool
  • refundOrder()from code
  • checkInventory()custom
    ← Internal API · GET /inventory

Reach anything

  • Your backend
  • Any HTTP API
  • Internal services
  • Partner APIs
  • Legacy systems

custom tools are governed, versioned, and logged like the rest

What it runs on

Three things worth knowing before you ship it.

It works as the person using it

The agent acts through the same session, the same roles and the same rules your product already enforces. Everyone gets exactly the reach they already have.

It lives where your users are

It runs inside the page they are already on, so it can act on what they are looking at and keep the interface in step with what it just did.

It stays in your hands

Turn capabilities on one at a time, publish frozen versions, promote between environments, and watch every call on both sides.

Built for your stack

It reads the framework you already use.

Faustine reads your application's architecture rather than a framework's conventions, so it understands the app you actually built.

Single-page applications
  • React
  • Angular
  • Vue
  • Svelte
  • Solid
  • Preact
  • Qwik
  • Lit
  • Ember

Working in something else? Tell us on the call and we will take a look at your repository.

Give your users an agentic experience.

Bring your repository to a 30-minute call and we will show you what Faustine builds from it.

Book a demo