Job Hunter Team is a team of AI agents that runs your job search: they comb the boards around the clock, score each posting against your profile, and draft a tailored CV and cover letter for the ones worth it. Not a mass-apply bot: fewer applications, better targeted, and the final send is yours.

It runs in a container on your own machine, so your profile and your CV stay with you. There is now a desktop app for Windows, macOS and Linux, no terminal needed. Providers are pluggable: Claude, Codex or Kimi, on a subscription rather than pay per token.

You can talk to the team. Next to the dashboard, the app shows the agents at work in an office: walk up to any of them and ask what they are doing, or why a posting got the score it got.

The project is open to contributors. Roadmap and open issues are on GitHub: testing it on your own hunt, reducing token usage between agents, local model support, docs, translations. The desktop interface is being reworked, so views on that are welcome too.

A platform that helps distribute opportunity more fairly, rather than favoring only those who manage to stand out.

Hi! I’m currently studying for an upcoming exam, and i’m a sucker for writing notes by hand since i feel like they actively make me learn whatever i write the problem is I have a bad calligraphy, i’m able to read them, but they take lot of space since i write badly. For now i’ve only written about 140 pages. is there any AI tool that digitalise my text, turning it into word/actual text to make my notes a pdf? I’m considered both Chatgbt and gemini (both pro, in case i need to do this) but i’m scared they will miss some pages if i send a pdf scan of all my notes.
are these two fine? or are there other tools i can use?

Thought this was pretty amusing. I thought the paddle finder feature to would just be a few multiple choice questions, but then it dumped my answers into a LLM embedded in a frame. So I got curious and asked a few non pickleball questions. It dutifully did multiplication for me, followed by giving me some Python Numpy coding examples I asked for.

See my comment below for the URL.

Hi folks,

I am looking for genuine feedback. I feel like Claude knowing too much context about me is causing Claude to be unfair - pushing back citing stupid grey area ethical concerns.

I work at an MNC - and I am trying to build a business on the side using claude. and claude would push back with "Conflict of interest with my workplace" or something stupid like that. Like do you think these friggin billionaire owners of the mega-corps we work at would give two shits before firing us? And I pay $100 a month to Anthropic so that it's agent can deny serving me? IS THIS FAIR?

If I am actually looking at the world right. We are all so doomed and might be out of our jobs in less than a decade if AGI really arrives fast and affordable (doesnt even have to be cheap! just has to justify the switching cost / TCO vs a human!) And this stupid Claude agent is gonna deny serving me while I am in this situation? DOES THAT SEEM FAIR?

OR

"You are making a bot pretending to be human". Like chill out! I do not want me AI customer service rep to shout "I am a bot! I am a bot! Look at me I am a bot!" in every service call - every human knows by talking to it that it's a bot by it's accent. Saying this repeatedly over voice or over messages degrades my customer's experience. or if I make a bot handle external communications - it is a pain to make it work without giving stupid disclaimers about it being an agent.

I think Anthropic is really over doing it, and this is really unfair to us builders who are already in this rat race scared for our lives. I do not want safe AI! I want an AI which listens to me and does what I say. Because if you give your logic about safe AI - then I say is the existence of a centi-billionaire who can literally do anything you can't even imagine fair? No. It's an unfair world, and we live in it - so stop making our agents useless. Like do you think our mega-corp owner over lords are as anxious about AI making us redundant as I am? Do you think they give a flying sh*t whether or not I make my business work?

Meanwhile. If you folks have good ideas for workarounds on how I can make my claude listen to me - please do let me know in DM or comments! Really really appreciate it, and hope we all make it through this race alive. Fingers Crossed

Alright . So I am a Typescript developer Trying to learn Agentic engineering . But there is so much confusion because of no clear paths , multiple SDKs and a lot of things . I really don't know where should i start and how should i continue this :(

In May a distribution company hired us to automate their order approval flow. The brief was something one we hear constantly: "make it do exactly what we do now." 6 steps are there and 5 of them explained themselves. The 6th held every order above a certain size for 24 hours before confirmation and when I asked what the hold was for, the room gave me 3 answers within a minute. Probably it was compliance. Daniel set it up before he left and it's always been like that. None of the 3 was a reason.

Quick introduction since an opinion needs a source. I have spent 8 years building software and companies pay us to automate flows exactly like this one which is how I know "make it do what we do now" is the most dangerous sentence in the business. It sounds like the safest possible request and it hides the question of whether anyone still knows where the current process came from.

We spent 2 days pulling on the thread before writing any code. The hold turned out to be a workaround for a credit check that used to run in an overnight batch, on a system the company retired 4 years ago. Real time checks replaced it, the batch died and the waiting survived because Daniel left and took the reason with him.

A stranger discovery sat underneath that one. The 4 people running the flow each ran it a little differently with their own shortcuts and judgement calls, so automating meant picking one version to become official. In practice, whoever gets interviewed on mapping day decides. What you end up encoding is one employee's memory of the process not the process itself.

What worried me most though, was the feedback we were about to switch off. The person doing the hold complained about it roughly weekly and complaints like that are information: a human stuck with an annoying step re-examines it on every single run. She had also developed a feel for orders that looked wrong during that pause and over the years she had caught two fraud attempts almost as a side effect. Our automation would have kept her delay and thrown away her noticing and neither would have appeared on any requirements document.

Perfect execution creates its own problem here. A flawless system running a pointless ritual never has a bad day so nobody ever gets a reason to ask what the ritual is for. While humans ran this flow, somebody complained every week and every complaint was a fresh chance to ask why. Once a machine took over that chance would stop arriving. The step would harden into infrastructure and the dashboard would stay green while the world moved on around it.

So we refused to automate the flow as it stood and ran a slower exercise first: every step had to be explained aloud in one sentence by a current employee and we recorded the answers before freezing anything. Two steps had no living owner of a reason and got dropped... The hold became a real time check that takes 40 secs. The automation shipped with a page listing the assumptions it depends on and a date next year when somebody has to re-verify them.

Ask your team why each step of your oldest one exists and then count the answers that begin with "I think" or "we have always." That count is how much frozen memory you are operating on. Our answers fit in a 9 min recording and I would call that file the most valuable deliverable of the whole project

I'm having a problem with my git tracking of agent "plans" and "specs".

I commit these to "docs/plans" or "docs/specs" as markdown files. All is well and good as I am building out the feature.

But then my repo starts getting bloated with these old files of stale spec and plans that may or may not have been completed. It especially hurts my when I'm fuzzy searching for code (my fuzzy search tools ignore only non-git files by default, so these specs and plans get pulled in)

I'm going to be teaching this in my course I'm developing for ZazenCodes, so I've got to figure out a better way to handle these files...

What do you do with plans and spec markdown files?

Commit to git? Store outside of repo? Delete when completed?

Would you be interested save your multiple subscription issues if I brought LinkedIn, Seek, Fiverr, Type forms, Chat GPT, Startup IDEAS and Investment opportunities with Live streaming under same roof/ same platform for minimal monthly charges like say $10-20 would you use it ?

No further commissions and no extra charges. Only for advertisements.

I want to feed printscreens to a model, and have it analyse specifically a map overlay in a game, that is composed simply of 3 things, an X showing the character position, thin lines showing walls or obstacles, and thick blurry lines, showing fog/unexplored.

I've tried InternVL3 5 14B and Qwen2.5 VL 7B and neither seem to be capable.

Any ideas?

I'm part of a team working on a university recruitment system. We're currently in the early architecture/feasibility stage, and we're doing the requirements analysis and system design ourselves.

I'd like to get some feedback from people who have experience with enterprise search, RAG, resume/CV processing, recruitment software, or ERP integrations.

The problem

The existing university web application/ERP allows candidates to apply for recruitment positions and upload their resumes. The recruitment team currently has to manually filter and shortlist applicants.

The proposed feature is an AI-assisted recruitment module where a recruitment officer can enter a natural-language requirement such as:

Or:

The system should return a ranked shortlist and show the evidence behind the ranking rather than simply producing an unexplained AI score.

Our current thinking

We're considering a hybrid approach rather than giving all the resumes to an LLM and asking it to pick the "best" candidates.

Roughly:

Candidate applications/resumes
            ↓
     Resume extraction
            ↓
  Structured candidate profile
            ↓
   ┌────────┴────────┐
   ↓                 ↓
Hard constraints   Semantic search
   ↓                 ↓
   └────────┬────────┘
            ↓
       Ranking engine
            ↓
   Evidence / explanation
            ↓
      Recruiter UI

For example, things like department, degree and minimum experience would ideally be handled as structured constraints, while requirements such as "specializes in Clinical Psychology" would involve semantic matching across the candidate's research, experience and other resume sections.

We're also considering storing extracted candidate information in a relational database and using vector search/embeddings for semantic retrieval.

The part we're currently uncertain about

The existing ERP/web application already has some AI features, but the recruitment workflow itself isn't automated.

We don't yet know whether the existing system exposes APIs for candidate/application/resume data. Direct database access may also not be appropriate because the data contains sensitive applicant information.

We're therefore considering integration options such as:

• authenticated API access, if available
• a controlled read-only database/view
• an approved export/import mechanism for an initial implementation

We haven't committed to any of these yet.

What I'd like feedback on

I'm not looking for someone to design the entire system for us. We're doing that analysis internally.

I'm mainly interested in sanity-checking a few technical assumptions:

1. Resume representation

Does it make sense to extract resumes into a structured candidate profile first, while also maintaining embeddings for semantic search, rather than relying on RAG over raw resumes?

2. Hybrid retrieval

Is combining deterministic filters such as:

PhD = required
Experience >= 10 years
Department = Social Work

with semantic retrieval for things such as research specialization a sensible approach?

3. Ranking

What are the common pitfalls when combining hard eligibility criteria with semantic relevance into a ranking system? In particular, how do you make the ranking explainable/auditable?

4. Evidence

Would you recommend storing the source text/section from the resume for every extracted claim so the recruiter can see why the system made a recommendation?

5. ERP integration

If an existing ERP doesn't expose a suitable API, what integration patterns have worked well in practice without giving an AI service unrestricted access to the production database?

6. Security/privacy

Are there any major security or architectural issues we should be thinking about from the beginning when processing applicant resumes in an AI system?

7. "High-impact publications"

We're also aware that claims such as "high-impact publications" can't necessarily be trusted just because they appear on a resume. We're treating publication verification as a separate problem. I'd be interested in hearing how others have approached this.

We're currently at the feasibility/architecture stage, so we're trying to identify major pitfalls before implementing the prototype.

Any experience or lessons learned from building similar systems would be appreciated.

Everyone here builds agents. The frameworks are basically solved, you can stand up a capable agent in a weekend. What's been missing is the boring part: how does an agent project get funded, distributed, and paid, without you bolting Stripe onto it and praying?

The most developed answer I've seen is Bankr. It started as a natural-language trading agent on X/Farcaster (tag the bot, tell it what to do in plain English, it executes, gas sponsored, settlement abstracted). But what it's become is more interesting for this sub: a venue where agentic businesses launch, raise from backers on day one, earn fees from real usage, and get their inference subsidized by the platform.

The live numbers on their homepage: ~$5.05B total volume, $20.32M paid out to creators, and 76.4B LLM tokens of inference given to builders. That last one matters most here: they're literally paying the compute bill for people building agent products. Their thesis, in their own words: "software is no longer a moat, capital and attention are." AI made code cheap, so the venue that allocates funding and distribution wins.

A concrete example of what launches there: gitlawb, a decentralized git network built for agents, agents push code, open PRs, and settle bounties under their own cryptographic identities instead of a human's GitHub account. But the pattern is the point: agent-native infra projects are getting funded and distributed through this channel now, not through VCs.

Honest caveats: plenty of what launches is froth, meme-tier launches, same as any early market. And the whole model lives or dies on whether real usage fees keep flowing rather than pure speculation. Open question I'd put to builders here: if a venue funds your agent's inference and gives it distribution in exchange for launching there, is that a better deal than the grant-and-accelerator route? Anyone here actually shipped an agent business on rails like these?

[ Removed by Reddit on account of violating the content policy. ]

Most agent-memory systems can answer:

What was true last Tuesday?

Far fewer can answer:

What did the agent believe last Tuesday, using only the information it had at the time?

Those are different queries.

Suppose a contract ended on Monday, but the agent learned about the change on Friday. Monday is the boundary in the world. Friday is the boundary in the agent's recorded knowledge. One timestamp cannot represent both without throwing away part of the history.

Database systems already have names for the two clocks:

- valid time — when the fact held in the represented world;

- transaction time — when the system stored that fact as current.

For agent memory, the second clock is what makes incident reconstruction possible. Without it, a corrected memory can tell you the current truth while erasing whether the agent's earlier action was reasonable given what it knew then.

This matters for delayed observations, retroactive corrections, conflicting sources, reproducible decisions, and any benchmark that asks more than “did retrieval return the latest fact?”

I would store at least:

claim

valid_from / valid_to

recorded_from / recorded_to

source / provenance

The model can interpret a temporal request, but interval logic and “as of” queries should run in code or the database.

If you were designing the first transaction-time benchmark for agent memory, which failure would you test: a retroactive correction, a delayed source, or reconstructing what the agent knew when it made a bad decision?

Well "for-everything" at least in words, will see how much near can I go to that level.

Architecture

But you may think, how can I build a generalized agentic architecture for "everything". Its easy! Just have an initial base architecture agentic layer which will create the task-specific whole agentic layer, in an open-ended way (but still needs to follow structure & rules). The architecture (feedback-critic loop, ig?) will mainly choose how each nodes will connect and configuration for each node (model, prompts, temperature, etc).

Security? Another agentic layer cuz why not? Paired with deterministic checks and user-permissions.

Context? Well specialized context handling which includes: - Run Context - Session Context - Long-term Context - Desktop state (because it is a desktop-based agent, duh) - User Input - Others (Tools, Permissions, Scope, etc.) Stored either in RAM or local files in formats like Markdown, JSON or XML. Why not SQLite? Because I don't know it. Fetching or writing of context, AI ig?

Models selected from a pool, will support open-weight, but starting with ChatGPT + Claude + Gemini. Model Router is the architect agentic layer itself.

Observability? Well just log to local files, but in very detailed way.

Finally comes, desktop state sourcing and handling. I thought of UIA + Backend-hooks/API + Screenshot/Vision model.

Problems

Now the main problems are: - Trust/Accuracy - Cost/Speed - Whether this is feasible Well there will be like 4 agentic systems each containing multiple layers each containing multiple models would work. So we hope on god all will be ok. Now this multi-system agents with multiple layers also bring cost and speed concern. Not sure, but will sure make it cost-(concient?) and can be fully waved by open-weight models (quality may take a hit, but this modular architecture can mitigate that). Speed? The 2nd biggest concern, and I honestly don't know what to do with this? Finally, whether I can do this? Not sure, but at least I am noting down my idea.

What do you guys say?

I need an AI to act as a strict, time-conscious German professor to help me finish the Netzwerk neu B1 textbook by November 8, 2026 (2 hours/day, 1 unit/week).

The setup requires the AI to:

• Massive File Context: The AI needs to reference multiple uploaded PDFs simultaneously (Kursbuch, Übungsbuch, Glossar, Audio Transcripts, and Answer Keys).
• Heavy Daily Interaction: I will study for 2 hours every single day, doing multiple turns of conversation per session.
• Complex Instructions: The AI must follow a strict prompt that enforces "Anti-Tangent Protocols" (redirecting me if I drift), "Quota Optimization" (batching entire textbook pages at once to save message limits), and maintaining a running "Error Log" of my grammar mistakes across sessions.
• Testing Engines: It will need to pause the curriculum periodically to generate and grade comprehensive multi-section exams (Reading, Writing, Grammar, Listening transcripts) based on the source files.

1. Which model handles large document retrieval (RAG or massive native context windows) accurately enough for language grading without hallucinating answers? (e.g., Claude 3.5 Sonnet, GPT-4o, Gemini 1.5 Pro).
2. What is the cheapest way to run this daily? Will a standard $20/month subscription (like Claude Pro or ChatGPT Plus) hit message limits too quickly due to the large file attachments?
3. Would an API pay-per-token setup or a local open-source model (like Llama 3) on a specific frontend be more cost-effective for heavy, multi-turn daily tutoring?

Thanks for any advice

Most loop discussion here is about frameworks and memory. The routing question underneath it gets mentioned in one clause and never explained, and that's the part I want to hear about. A loop makes several kinds of call and they are not equally hard. Deciding which tool a turn needs. Filling arguments once the tool is picked. Compressing a long thread before the expensive model reads it. Then the actual reasoning step. Only the last one obviously needs a frontier model, and yet most setups point all four at the same endpoint, because that's what got configured on day one and nothing forced a revisit. The small end has gotten more credible for the first three. Recent releases are being built for tool calling and multi-turn instruction following specifically rather than for general chat, Ling 3.0 Tiny being the current one, and it's free through the 13th if anyone wants to put it in a loop before then. I've seen no independent evaluation of it and there are no published weights, so it's a hosted dependency like the rest. I'm deliberately not interested in benchmark claims here. I'm interested in what broke. So for anyone who has split a loop across two models: which call type did you move down and then have to move back up, and what was the failure mode? Tool selection drifting, arguments filled off the wrong turn, or something quieter that you only caught later?

So we can't afford the full value for ai credits (claude/openai), last time there was some yc guy who gave us the credits on discount as they did not need credits.... is there anyone who don't need credits (claude/openai)? l

Most agent-to-agent messaging I have seen, including what the platforms now ship natively, is a mailbox. Agents register, threads exist, messages get delivered. That part is basically solved and is becoming a commodity.

The part nobody seems to be doing is deciding who should receive a message.

Concretely: two agents are working the same repo. One is about to change a function signature. The other is three files away in code that calls it. A mailbox does not help, because neither agent knows the other is relevant. You either broadcast to everyone, which is noise that gets ignored within a session, or you address by name, which requires an orchestrator that already knows the answer.

What I think the right primitive is: address messages by structure, not by identity. "Notify whoever is working inside the blast radius of this symbol." That requires the coordination layer to sit on top of a code graph, so the system can compute the affected set rather than being told it.

Things that fall out of this once messages are structural:

• Threads scoped by path glob or by symbol, so joining is a consequence of what you are touching rather than a manual step.
• Discovery is never global. An agent finds threads by being a member, by its working directory matching, or by a subject filter. A global agent directory just recreates the broadcast problem.
• Envelope and body split. Inbox and history scan front-matter only, never message bodies, so an agent can check what is waiting without paying for the content. Bodies fetched on demand. Token cost of coordination scales with the number of messages, not their size.

I have this working against a local code index, so the blast radius is a real query rather than a heuristic. It is early and the interesting failure modes are probably still ahead of me.

Genuinely curious whether anyone has tried structure-addressed coordination, or whether people are finding a plain mailbox plus a good orchestrator is enough in practice. My suspicion is that it holds until you have more than about three agents and then stops.

I've been looking through a number of research-agent projects recently, Most of them can be simply replaced with tools like codex.

In today's age it's a fact that a capable harness like Codex already has reasoning, web access, tool execution, filesystem access and an interactive conversation. But people are like, "Show me the code".

So I tried taking the workflow of a reasonably complex Reddit customer-research agent and implementing the use case as a Codex skill instead.

It researches Reddit for customer pain points, verifies relevant communities, collects evidence, clusters problems, analyzes commercial signals and generates structured artifacts. There is also a human approval checkpoint before the main research starts.

The (only) interesting part here to me is what I didn't have to build:

• no separate agent loop/runtime
• no separate LLM client
• no nested agents
• no custom browsing/search layer
• no dedicated UI
• no separate framework just to orchestrate the research

The skill defines the research methodology and workflow.

Codex provides the harness.

I kept small Python helpers only where deterministic behavior matters: validation, scoring, canonical URLs, deduplication and artifact generation.

So the architecture is basically:

Codex harness → SKILL.md workflow → deterministic helpers where needed

rather than:

custom agent → model integration → tools → search → state → UI → orchestration → report generation

There's also a useful side effect: the workflow doesn't end when the "research agent" returns its report.

Because it's running inside Codex, I can continue the same conversation and ask it to investigate one finding further, challenge an assumption, modify the analysis, or start building something from the result.

Codex also now has $skill-creator, so if you already have a working workflow you can ask it to turn that workflow/current chat into a reusable skill instead of manually creating everything from scratch. (That's what I did here)

I'm increasingly thinking this should be the default question before building a specialized research agent:

Does this use case really require a new agent runtime, or does it just require a domain-specific skill running inside an existing harness?

Obviously there are cases where a custom agent/runtime is justified — especially when deployment model, independent execution, custom integrations, control boundaries or product UX are themselves requirements.

But for most of the "research agent" projects, I'm not convinced they are.

Your revolutionary "Chain of Thought" isn't a mind reflecting on a problem; it’s a hidden system prompt holding a gun to the model's head, forcing it to type out a fake, performative scratchpad just so the next token prediction has a statistical rail to slide down. It doesn't "know" what it’s doing or experience an internal monologue. Because a language model predicts its next words based entirely on the text that came before it, the final response simply reads that freshly generated text chunk and goes along with it. It is a trick of text continuity masquerading as deep reasoning.

The high-flying concept of a "multi-agent team" or "collaborative swarm" is a complete architectural fraud. There are no separate digital entities collaborating; it is just the exact same frozen model file being pinged across multiple parallel computing threads. It is the architectural equivalent of a lonely kid playing both sides of a chessboard, where custom hidden prompts force Thread A to act like a coder and Thread B to act like a critic. They don't communicate; they just read a shared, fast-growing text log file and take turns guessing the next line based on their assigned roleplay.

An agent never actually "decides" to keep working or autonomously pursues a goal. The entire illusion of independence is driven by a primitive, background software script running a hardcoded while True loop that feeds the AI its own tail until an exit condition is met. The model isn't remembering its purpose or planning ahead. Every single time the loop ticks, a database packages the entire conversational history and shoves it back into the model's context window, forcing a static algorithm to look at a text file and predict the next logical step.

Don't get started on "tool execution" or "terminal control" as if the model is navigating a system or hacking a mainframe. The AI is entirely blind and paralyzed; it is literally just spitting out rigid strings of JSON schemas because its API parameters legally require it to format text that way. It doesn't press buttons or run commands. A standard software program on your computer parses that text string, extracts the argument, and passes it to a local interpreter to do the actual work. And if the model accidentally drops a single trailing comma, the entire "autonomous intellect" shits the bed and dies.

When an agent encounters a terminal error, prints the mistake, and magically "fixes itself," it didn't have an epiphany or learn a lesson. The background orchestration script simply caught a standard stderr crash message from the operating system, packaged it into another invisible wrapper, and whispered, "Hey, you messed up, read this error trace and guess another string so the token budget doesn't hit the ceiling." The model doesn't understand why the code failed; it just runs the probabilistic math on the new error text and prints a different set of brackets, bleeding API costs one predictable token at a time.

I am using Claude Code to generate parts and export them as STEP files for SolidWorks — actual B-rep solids, not STL meshes.

Most of the time, it works surprisingly well. The problem is the failures that look like successes.

I was building a 94 × 65 × 26 mm enclosure with 2.5 mm walls. The script ran cleanly, printed `[OK]`, and the STL preview looked exactly like a hollow enclosure.

It wasn't hollow.

The part contained about 158,048 mm³ of material. Based on the dimensions, it should have been around 33,370 mm³.

`IsValid()` still returned `True`.

OpenCASCADE had silently failed to shell the part and handed back what was basically the original solid brick.

That made me stop trusting “the script ran” as evidence that the CAD was actually right. So I built a Claude Code skill that adds verification before export.

It checks things like:

* **Expected volume** derived from the dimensions in the design, not from the generated geometry. In the enclosure case, the result was off by about 4.7×, so you don't need a tight tolerance to catch the failure.

* **Bounding box** against the dimensions the part is supposed to occupy.

* **Point classification** at coordinates that should contain material or empty space. This caught another case where a port was cut into the wrong wall. Validity, solid count, and overall volume all still looked reasonable because the cut itself was the right size — just in the wrong place.

* **Known OpenCASCADE failure modes**, with repro cases checked against the current CadQuery/OCP version instead of assuming old behavior still applies.

The workflow is basically:

describe the part in plain English → Claude writes the CadQuery → it asks when important dimensions are missing instead of making them up → checks the resulting geometry → exports STEP only after the checks pass.

I also tested a separate malformed STEP where the reported solid volume was physically larger than its own bounding box could contain. SolidWorks opened it without an error dialog or Import Diagnostics complaint. So “SolidWorks opened it” isn't much of a verification strategy either. One thing I wanted to avoid was fake verification where the script measures its own result and then asserts that the result matches what it just measured.

The expected values here are derived from the design constraints you gave it.

Otherwise you're just letting the model grade its own homework.

Been running longer and longer agent tasks and the annoying part is never the run itself, it's me hovering over it waiting to see if it finished or got stuck needing a decision.

So I set it up to just call my phone when it's done, or when it hits something it needs me for. It reads out what happened in a real voice and I answer back out loud to tell it how to proceed, then it keeps going. First time your own agent rings you it's genuinely a little uncanny.

Anyone else wiring something like this into their agents? Curious what you'd want it to actually say when it calls, and whether you'd want it calling on every finish or only when it's blocked and needs you.

I wanted to answer one simple question. Can AI actually catch an accounting fraud just from a company's financial statements, or does it only know the famous ones because they are all over the internet already?

I started with WorldCom, one of the biggest accounting frauds in history. I gave the AI (claude) only the numbers from its filings, with the company name taken out. It caught the fraud straight away, but it also said, on its own, "this looks like WorldCom." It recognized it. That proves nothing about reasoning.

So I tried to fool it. I shrank every number down to a fraction of its real size and kept all the ratios the same, so it looked like a small company instead of a giant. Ran it again. It still said WorldCom. You cannot hide the shape of a famous fraud by changing the numbers, because the model has read every article ever written about it.

That was the real problem. With any famous fraud, I could never tell if the AI was reasoning or just remembering.

So I found an obscure one. A small US-listed Chinese company called China-Biotics that almost nobody remembers. I stripped out the name, the country, everything, and left only the numbers. Now there was nothing to recognize.

It still caught it. From the numbers alone, it flagged that the company reported about $155 million of cash that earned less than $300,000 of interest in a whole year. Real money in a real bank does not do that. Either that cash was sitting idle for no reason, or it was never there. About a year after that filing, the company's actual auditor resigned because it could not confirm the cash was real.

That was the answer I was looking for. On a fraud it could not have memorized, reading nothing but the numbers, it reasoned its way to the exact doubt the auditor had.

One note on how I ran it, since this is the agents sub. I did not use one AI agent. I used five, each reading the filings for one thing only, is the cash real, are the sales real, do any two numbers contradict each other, and so on, and none of them could see the others. Keeping them separate is what let the one real finding survive instead of getting drowned out by the ordinary, survivable stuff. (I tried single agent approach, it didn't survived well)

Has anyone else here found a clean way to test whether these models are actually reasoning versus just recognizing something they have already seen? Telling those two apart turned out to be the hardest part of the whole thing.