TalenBridge

Inspiration

I've been on the wrong side of the 2026 hiring funnel. I'm a final-year IT student who has shipped real systems - a courier-aggregation platform handling live NDR/RTO logistics, production WebSocket auth, a dozen deployed projects - and I've still watched applications vanish into ATS filters that scored my résumé on keywords, not on anything I actually built.

So when I read that 19% of organizations using AI in hiring admit their tools have screened out qualified people, it wasn't a statistic to me. It was my inbox. Both sides of hiring now run on AI - recruiters screen 300+ résumés per role, candidates generate applications in seconds - and the two sides' agents have no way to talk to each other. They just escalate the noise. I wanted to build the layer that sits between them, where each side's verified context can meet the other's under rules both parties control.

When I found Aicoo - a coordination layer where agents from different people connect, share permissioned context, and revoke it - I realized it was the missing primitive. Not a feature I'd bolt on. The spine.

What it does

TalentBridge is a two-sided hiring coordination demo. A candidate and a recruiter each publish verified context to their own Aicoo Pulse account, then share a scoped, read-only, revocable link to their agent. The product does three things no keyword filter can:

• CLEARED - aligned matches clear fast, with workflow actions (drafted intro, Pulse ping, booking link shared only when comp actually aligns).
• BLOCKED - hard conflicts (a role below the candidate's comp floor, a relocation the policy forbids) are caught at the coordination layer before anyone wastes a call.
• RESCUED - the one that matters most to me: a candidate whose résumé keywords read weak but whose verified Pulse context proves the capability. An ATS would reject; TalentBridge surfaces the truth: "Resume-keyword match WEAK, verified-context match STRONG - the coordination layer confirms the fit."

Each side queries the other side's agent directly, and either party can revoke access mid-conversation - the context disappears from a live session in real time.

How we built it

The stack is Next.js 14 (App Router) + TypeScript, Tailwind with a custom Syne/DM Sans design system, and Framer Motion. Two Pulse API keys live server-side only; every Aicoo call is proxied through Next.js API routes so keys never touch the browser.

The Aicoo integration spans the whole Pulse Layer: POST /init and /accumulate to publish scoped markdown context, POST /share/create with scope: folders and identity.loadPolicy: true to mint guest links, GET /share/list for live analytics, DELETE /share/{id} for the revoke beat, and the guest-v04 streaming endpoint (NDJSON, not an iframe) so each agent answers in its own voice. Human-in-the-loop runs through send_message_to_human, and I wired the heartbeat endpoint for autonomous actions.

The most important design decision: the fit verdict is deterministic, not generated. A pure TypeScript engine (compute-fit.ts) computes CLEARED/BLOCKED/RESCUED from the two structured contexts, and the guest agent only narrates that verdict via an injected preamble. That split is what keeps the subtle RESCUED case from drifting on camera - the agent explains a decision the app already made and can defend.

Challenges we ran into

The biggest one was epistemic, not technical: Aicoo's marketing language describes an "agent router" that the API doesn't actually expose. I had to read the real docs end-to-end and design around documented primitives - share links + identity scoping

• guest agents - rather than the autonomous bot-to-bot negotiation the framing implied. That meant cutting features I'd scoped and being honest about what coordination actually ships today.

Second: making the verdict bite. My first build was two agents politely describing two documents - mechanism, not solution. The fix was reseeding for a near-miss and building the RESCUED scenario, so the product visibly catches what a keyword filter can't, instead of just confirming obvious matches.

Third: the live-revoke beat. Getting the recruiter's panel to die cleanly on the next message after a DELETE, with the right state transition (amber warning → session killed) instead of a confusing error, took careful handling of the guest-v04 404.

Accomplishments that we're proud of

• The RESCUED verdict - a genuine false-negative rescue, computed across two permissioned Aicoo contexts, that no résumé keyword screen could produce.
• A live revoke that kills an active diligence conversation in one click - the clearest possible proof that the product can't exist without Aicoo.
• Deep, honest use of the Pulse Layer: eight distinct primitives, each load-bearing in the demo, with a deterministic verdict engine the agents narrate rather than guess.
• Shipping it solo, end to end, as a final-year student.

What we learned

I learned to read an API for what it guarantees, not what its homepage promises - and that designing around documented capability is what separates a stable demo from a fragile one. I learned that a coordination product wins on the moment the coordination changes an outcome you can see, not on feature count. And I learned that the honest framing - "this is a rule-based verdict on published policy, narrated by the agent" - is more persuasive than overclaiming autonomy, because it's defensible.

What's next for TalentBridge

• Parse the fit signal live from accumulated markdown instead of structured scenario inputs, with an embedding model for capability matching.
• Real workflow integrations: SMTP for the drafted emails, Calendly API for booking, beyond the current agent-drafted copy.
• A third agent surface for asynchronous candidate↔recruiter handoff, and a heartbeat policy that proactively surfaces matches.
• Bias-audit transparency (NYC Local Law 144-style) baked into every verdict, since the whole point is making automated screening accountable instead of opaque.

Built With

• aicoo
• framer-motion
• guest-v04
• lucide-react
• ndjson
• nextjs
• node.js
• pulse-api
• react
• react-markdown
• tailwindcss
• typescript
• vercel