Contract software company fynk says it removed about 11,000 lines of its own AI chat code by adopting two open-source pieces, the AG-UI protocol and the CopilotKit framework, and that it wrote the Vue version of CopilotKit itself. The company's account is on the fynk blog, published November 2, 2026 by Constantin Wintoniak. It also appeared on Hacker News, where it had 8 points and no comments when we checked, so there is no discussion to report.
It is a vendor's own write-up, with numbers we cannot independently check. It is still useful, because it is specific about what the team adopted, what it built, and what went wrong. This post pulls out the parts that transfer to other teams building an in-app agent.
The numbers at a glance #
| Item | fynk's figure |
|---|---|
| Code removed from fynk | About 11,000 lines |
| Vue port pull request | 62,517 lines across 244 files |
| Merged into CopilotKit | May 13, 2026; @copilotkit/vue on npm the same evening |
| Timeline | About 3 months from first commit (February) to merge; 8 months until documentation was done (October) |
| People | One engineer plus a coding agent, alongside other work |
| Follow-up | More than 20 Vue fixes and features from others; 5 more merged pull requests from fynk |
| Assistant shipped | August 2026, on every plan |
What was wrong with the first chat? #
At the start of 2026 fynk had a document chat it had built itself. It answered questions about one contract at a time. The company says every piece of an answer came in a message format it had defined, a wrapper around a chunk of text with a slot for PDF coordinates, and that this format "knew two things: a piece of text, and where in the PDF it came from."
Anything else needed a new field in both the frontend and the AI service. Comparing two contracts meant changing the format. Showing a table meant a new message type. Letting the agent ask whether to open a document meant another state in a hand-written state machine that ran over a WebSocket the company calls unreliable. Its conclusion: "We were building the same basics that every company with an AI agent needs. When that happens, you should stop building them yourself."
What does AG-UI change? #
fynk's own write-up describes the swap. The chat panel, streaming state and wire protocol that it hand-built became CopilotKit components, an AG-UI client and an AG-UI plus LangGraph adapter. Three things it had not built at all, tool calls in the UI, human in the loop, and shared agent-to-UI state, arrived with the framework.
The post shows the same sentence, "The notice period is three months," in both formats. The old one was one JSON object with a message chunk. The new one is five standard AG-UI events: a run-started event, a text-message start, a content event with the text, a text-message end and a run-finished event. More lines for one sentence, but the next feature needs no new format. Compare two contracts and the same stream carries tool-call events and a state snapshot.
The architecture fynk describes has three layers. The agent runs in its AI service, built with the open-source LangGraph framework, and an AG-UI adapter turns its output into events. The backend keeps threads and history. The frontend renders events with CopilotKit. The events follow the standard, and conversation history stays in fynk's own backend.
If you follow CopilotKit's other work, we covered its OpenDuet proactive agent and the earlier OpenBot coworkers project.
The Vue port: contribute, fork or wait #
CopilotKit was React-only and fynk's app is Vue. The company lays out the options. Forking is fast for about a month, then you maintain someone else's code alone. Waiting is free unless the feature is the thing customers want. Contributing is the expensive option up front: you meet maintainers' standards and keep up with their pace, and in return you stop being the only people who care about your code.
fynk contributed. Engineer Abel Enekes started in February "expecting to write a couple of lines" with a coding agent. The pull request came in at 62,517 lines across 244 files, built tests first against CopilotKit's own React test suite. Maintainers reviewed it, fixed the architecture where needed and merged it on May 13, 2026.
The payoff, per fynk: since May, others have shipped more than 20 Vue fixes and features, including a threads drawer, documentation, human-in-the-loop fixes and accessibility work. A fork would have given fynk none of that.
What the coding agent did and did not do
The company says most effort went into telling the agent what to do and checking the result: porting tests before code, writing decisions into an AGENTS.md file and a parity document instead of repeating them in every prompt, and checking that each test did what its name said. One quoted line from the engineer: "I asked for 1:1 tests, I got 1:1 test names." That is a reminder that agent-written tests can match names without matching behaviour. We have covered the same worry in our posts on whether developers should stop reviewing AI-written code and tests rather than reviews.
What makes an in-app agent trustworthy? #
fynk lists five building blocks it says make people trust an assistant with contracts:
- Shared state. The agent knows which documents are in context. Open a contract and it is already attached.
- Tool calls in the chat. Every step arrives as an event, and each answer carries a collapsible "Finished in N steps" trace.
- Human in the loop. The agent s and asks before it opens a document or changes anything. Before it moves a contract back from signing, it shows what will happen, for example that it "cancels the current signing process and invalidates any existing signatures," and waits for a click.
- Generative UI. The agent renders the company's own components in chat, such as a comparison table that can be downloaded as CSV or Excel.
- Citations and permissions. Clicking a numbered citation scrolls the contract to the clause and highlights it. The assistant has exactly the access rights of the user, and it waits for approval checkpoints just as a person would.
On the cost of adding one such confirmation card, fynk says it would have touched five places in the old chat and taken about two weeks. Now it touches two places and takes about two days. That is a company estimate, not a measurement we can check.
What should you build and what should you adopt? #
The most reusable part of the post is its table. Our summary of fynk's own decisions:
| Layer | fynk's choice | Why |
|---|---|---|
| Chat UI, streaming, message list | Adopt (CopilotKit) | Most of the old chat code lived here |
| Agent-to-UI wire format | Adopt (AG-UI) | Events for text, tools, state and s already existed |
| Shared state, tool rendering, human in the loop | Adopt | A hand-written state machine handled only one document |
| The tools themselves | Build | The assistant uses the same tools as the company's API and MCP server, so each is written once |
| Permissions and approval checkpoints | Build | The logic already lived in the product |
| Citations into the source | Build | Highlighting a clause needs its own document viewer |
| Where data and AI run | Decide early | Customers ask where contracts are processed; fynk says AI processing stays in the EU and data is not used for training |
The reuse of the same tools across the API, the MCP server and the assistant echoes the pattern in our guide to MCP and our explainer on agent skills.
What this does not show #
- It is a company write-up. The numbers come from fynk. We did not review the repositories or measure the assistant.
- No benchmark. Nothing in the post measures answer quality, error rate or user satisfaction beyond a customer quote.
- One stack and one domain. A Vue app with a LangGraph backend and a contract product may not match yours.
- Migration costs are mentioned but not quantified. The company notes that existing chats had to move to the new setup, history included, and calls that "real work of its own."
- No independent comment yet. The Hacker News thread had no comments when we checked.
How to try it yourself #
If you build on Vue, the fynk post says @copilotkit/vue is available. If you use another frontend, the sensible first step is to read the AG-UI event list and see whether your agent framework has an adapter. Both projects are open source: see the CopilotKit repository and the AG-UI repository. Then prototype the one feature that hurts most in your current chat, usually a confirmation step or a tool-call trace, and compare the effort with your hand-built version.
Related reading #
Figures are fynk's own, accurate as of November 2, 2026.