{"as_of":"2026-08-20T18:45:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:bca4592ede5e967399f5420928c402ebc77e911c5128fb41addbdb430ff3ccc4","coverage":[{"denominator":33,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":33,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-10T23:17:48.617881Z","state":"measured"},{"denominator":35,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":35,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-20T06:33:59.587034+00:00","state":"measured"},{"denominator":2,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":2,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-15T21:58:07.683838Z","state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":1,"source":"arxiv_reference","source_observed_at":"2026-08-05T02:28:24.338817Z","state":"measured"}],"external_citation_measurements":[{"count":0,"observed_at":"2026-08-05T02:28:24.338817Z","source":"arxiv_reference"}],"inbound":[{"citation":{"cited_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2502.17442","snapshot_observed_at":"2026-08-15T21:58:07.683838Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2505.08532","last_updated":"2025-05-13T13:03:20Z","snapshot_observed_at":"2026-08-20T14:24:54.197678Z","submitted_at":"2025-05-13T13:03:20Z","title":"The Truth Becomes Clearer Through Debate! Multi-Agent Systems with Large Language Models Unmask Fake News","version":1},"reference_index":56,"source":"pdf_text","source_observed_at":"2026-08-15T21:58:07.683838Z"},"links":{"cited_paper":"/paper/2502.17442","citing_paper":"/paper/2505.08532"},"observation_digest":"sha256:00eb837b228c9713e8983f2f3e49efbed35fc7fd0a6977b9d4324f0553fde41c","observation_id":"14073cf2-6be9-407e-9b56-5614c0f3be6d","resolution":{"observed_at":"2026-08-15T21:58:07.683838Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"cited_work":{"arxiv_id":"2502.17442","doi":"10.48550/arxiv.2502.17442","metadata_source":"arxiv_reference","pith_arxiv_id":"2502.17442","snapshot_observed_at":"2026-08-05T02:28:24.338817Z","title":"doi:10.48550/arXiv.2502.17442 arXiv:2502.17442 [cs]","venue":"ArXiv.org","work_id":"33c91fe4-a569-4fbd-87ed-db5b40239ae3","year":null},"citing_paper":{"arxiv_id":"2604.21598","last_updated":"2026-04-28T05:10:28Z","snapshot_observed_at":"2026-08-15T23:31:49.007718Z","submitted_at":"2026-04-23T12:21:03Z","title":"You Don't Need Public Tests to Generate Correct Code","version":2},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-05-09T20:57:43.802195Z"},"links":{"cited_paper":"/paper/2502.17442","citing_paper":"/paper/2604.21598"},"observation_digest":"sha256:fc419f572130d2c2324388a38605bfb897e0d53f0a056010fc5052386db31e0e","observation_id":"62e98827-1b4c-411a-be75-ea9b2914b20d","resolution":{"observed_at":"2026-05-09T20:58:06.467878Z","resolver_source":"arxiv_id","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}}],"links":{"evidence":"/evidence","html":"/paper/2502.17442/citation-record","integrity":"/paper/2502.17442/integrity","json":"/paper/2502.17442/citation-record.json","paper":"/paper/2502.17442"},"outbound":[{"citation":{"cited_paper":{"arxiv_id":"2108.07732","last_updated":"2021-08-16T03:57:30Z","snapshot_observed_at":"2026-08-15T17:40:38.050939Z","submitted_at":"2021-08-16T03:57:30Z","title":"Program Synthesis with Large Language Models","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2108.07732","snapshot_observed_at":"2026-08-10T23:17:48.473984Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":1,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.473984Z"},"links":{"cited_paper":"/paper/2108.07732","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:e306141526718975f2c1b3ba85b58f295e0adc66dbd823e7e154f5d891e2757e","observation_id":"e5d3caa3-bf88-4110-beee-fcef74110ac9","resolution":{"observed_at":"2026-08-10T23:17:48.473984Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.124723Z","title":null,"venue":null,"work_id":"bc128814-ac9b-4538-82f2-2a9efd34b57d","year":1960},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":2,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.479445Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:7b27bda02c203594a7ad3496c2b3c851127fd37374e1af4f378cfeb9ad611670","observation_id":"54d32a8b-7329-4052-b765-284465de6546","resolution":{"observed_at":"2026-08-10T23:17:49.129014Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2309.16609","last_updated":"2023-09-28T17:07:49Z","snapshot_observed_at":"2026-08-20T15:31:01.041088Z","submitted_at":"2023-09-28T17:07:49Z","title":"Qwen Technical Report","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2309.16609","snapshot_observed_at":"2026-08-10T23:17:48.484004Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":3,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.484004Z"},"links":{"cited_paper":"/paper/2309.16609","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:69eb645529e0bd449f25df7d042caebc11fa49eed973821e174df618878cdfa0","observation_id":"e3556d81-e9b9-4a2e-9fd1-6103803ceeaf","resolution":{"observed_at":"2026-08-10T23:17:48.484004Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.489110Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":4,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.489110Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:a4a3d8caef442f9589fcd6f73f2908b5c3590d9b4fecb8eb1db763c58bc93fdf","observation_id":"e7dd3b57-abed-42c3-b5cc-957f58ead7b2","resolution":{"observed_at":"2026-08-10T23:17:48.489110Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2303.16749","last_updated":"2024-02-22T22:30:31Z","snapshot_observed_at":"2026-08-16T15:44:39.724786Z","submitted_at":"2023-03-28T16:15:31Z","title":"Improving Code Generation by Training with Natural Language Feedback","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2303.16749","snapshot_observed_at":"2026-08-10T23:17:48.493851Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":5,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.493851Z"},"links":{"cited_paper":"/paper/2303.16749","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:20decb2b18b4f86d68666fb5d7545266e381f492826c33be2f064648ec848f47","observation_id":"401c170f-e5f1-4bea-91b4-84cf1145ed3d","resolution":{"observed_at":"2026-08-10T23:17:48.493851Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2107.03374","last_updated":"2021-07-14T17:16:02Z","snapshot_observed_at":"2026-08-08T11:58:24.516369Z","submitted_at":"2021-07-07T17:41:24Z","title":"Evaluating Large Language Models Trained on Code","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2107.03374","snapshot_observed_at":"2026-08-10T23:17:48.498759Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":6,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.498759Z"},"links":{"cited_paper":"/paper/2107.03374","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:06770d12c1be48fac1d611b29a46622c39f60d51c3c02354fd05718170b8a89e","observation_id":"c1a46184-3c9a-4e1f-bfd6-bbe4785b163a","resolution":{"observed_at":"2026-08-10T23:17:48.498759Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2301.09043","last_updated":"2024-09-05T14:00:11Z","snapshot_observed_at":"2026-08-16T16:00:56.417816Z","submitted_at":"2023-01-22T02:59:59Z","title":"CodeScore: Evaluating Code Generation by Learning Code Execution","version":4},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2301.09043","snapshot_observed_at":"2026-08-10T23:17:48.503962Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":7,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.503962Z"},"links":{"cited_paper":"/paper/2301.09043","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:caee36bbb58429b0dcaa4e337ff33b5973c5294c155c3b61e681f0b6503bba23","observation_id":"fab6e0b4-8cdf-42ba-92e0-d797820f6fd0","resolution":{"observed_at":"2026-08-10T23:17:48.503962Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.508691Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":8,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.508691Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:a591d4a0c4325cfaa1e784ea836fe64c5592db9501eec1a825d277527dd6bba7","observation_id":"5f9689d7-7977-4de3-bed8-1a6a7c60387b","resolution":{"observed_at":"2026-08-10T23:17:48.508691Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.08998","last_updated":"2023-08-21T10:23:42Z","snapshot_observed_at":"2026-08-13T14:38:32.919809Z","submitted_at":"2023-08-17T14:12:48Z","title":"Reinforced Self-Training (ReST) for Language Modeling","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.08998","snapshot_observed_at":"2026-08-10T23:17:48.512842Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":9,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.512842Z"},"links":{"cited_paper":"/paper/2308.08998","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:70e18ddeefec0a5eb42fad892038138ca7a4e742afbaa29b33491d81899511ce","observation_id":"dec747df-4f79-4569-b016-fab42a29f75b","resolution":{"observed_at":"2026-08-10T23:17:48.512842Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.093708Z","title":null,"venue":null,"work_id":"e381f45b-7465-40fe-95e0-dec50744d731","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":10,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.517534Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:18a3d8658d3a1124a0a875a65f92fac66a6f044a065ecd9b136cb01dbb6c9d21","observation_id":"feca80aa-84df-42ab-aadc-193e65ef4d8d","resolution":{"observed_at":"2026-08-10T23:17:49.098014Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2106.09685","last_updated":"2021-10-16T18:40:34Z","snapshot_observed_at":"2026-08-20T11:47:17.477107Z","submitted_at":"2021-06-17T17:37:18Z","title":"LoRA: Low-Rank Adaptation of Large Language Models","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2106.09685","snapshot_observed_at":"2026-08-10T23:17:48.521708Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":11,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.521708Z"},"links":{"cited_paper":"/paper/2106.09685","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:ac0f632577cd87db611ffb83728027a3e9d8af4cf3977d9d254a922c08170605","observation_id":"04fc2a8b-916d-474e-ac6f-7d2504bfdf5f","resolution":{"observed_at":"2026-08-10T23:17:48.521708Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.08784","last_updated":"2024-02-23T04:56:37Z","snapshot_observed_at":"2026-08-16T17:40:11.359239Z","submitted_at":"2023-08-17T04:58:51Z","title":"CodeCoT: Tackling Code Syntax Errors in CoT Reasoning for Code Generation","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.08784","snapshot_observed_at":"2026-08-10T23:17:48.526393Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":12,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.526393Z"},"links":{"cited_paper":"/paper/2308.08784","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:c6feb3d528ee13ec0b04d12e7038e9e3292b86e0db4256f7f667fc16d828837a","observation_id":"2fb5f049-3ed6-4abe-9052-cc552b1095a4","resolution":{"observed_at":"2026-08-10T23:17:48.526393Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2312.13010","last_updated":"2024-05-24T11:47:24Z","snapshot_observed_at":"2026-08-20T11:21:36.102557Z","submitted_at":"2023-12-20T13:22:41Z","title":"AgentCoder: Multi-Agent-based Code Generation with Iterative Testing and Optimisation","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2312.13010","snapshot_observed_at":"2026-08-10T23:17:48.530234Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":13,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.530234Z"},"links":{"cited_paper":"/paper/2312.13010","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:aed00c46131a068936c2e9058a3d3bfafad559c305700e7cb42ea09f3d924897","observation_id":"41c894e7-964d-430b-9d32-9e0b8df86c9f","resolution":{"observed_at":"2026-08-10T23:17:48.530234Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2405.11403","last_updated":"2024-05-18T22:10:15Z","snapshot_observed_at":"2026-08-16T13:51:36.604031Z","submitted_at":"2024-05-18T22:10:15Z","title":"MapCoder: Multi-Agent Code Generation for Competitive Problem Solving","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2405.11403","snapshot_observed_at":"2026-08-10T23:17:48.533949Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":14,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.533949Z"},"links":{"cited_paper":"/paper/2405.11403","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:c14b9ca0e4df3cd1c6cdb5b32ad3a1640543b0b1ec475c5ff5c2f4a866518190","observation_id":"3268fca6-7795-47c3-b845-678e0a490c70","resolution":{"observed_at":"2026-08-10T23:17:48.533949Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.080536Z","title":null,"venue":null,"work_id":"5b3bf2fc-c798-469a-9f78-fa2823382c03","year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":15,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.537646Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:2c5910dbe877f3795e92d8abe43d63abbf289d2699b08cf6dc075c7745d4648f","observation_id":"601cd8eb-6a9e-431c-9b67-2f0f551e1cba","resolution":{"observed_at":"2026-08-10T23:17:49.084848Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.066056Z","title":null,"venue":null,"work_id":"5f0d8e30-72b4-45ef-8dcd-967993cff026","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":16,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.541473Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:6fb5231074a66db4fde0aff0eee07a8fb34c48fa8dd48423c5cf3bc90633a9ed","observation_id":"58cf11a8-9c49-411b-a07f-c4f901eb526e","resolution":{"observed_at":"2026-08-10T23:17:49.071299Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.051916Z","title":null,"venue":null,"work_id":"485409af-8384-4bc7-92eb-316c36507450","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":17,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.544983Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:9efc0c6f3723d1a07ced1ca5bf52164718381d4ba51a418e45daf8c50a5e19d1","observation_id":"2ef21f99-d3c8-4985-8a30-598479c7566d","resolution":{"observed_at":"2026-08-10T23:17:49.056203Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.038683Z","title":null,"venue":null,"work_id":"444c3c4d-8d84-476f-be16-8614064bd184","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":18,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.548936Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:4dfb930e8e83795ba5489389b84910de1ddf873d28cd385537f592b899448847","observation_id":"87398bf2-48f6-488f-b625-8d5864481984","resolution":{"observed_at":"2026-08-10T23:17:49.042972Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.553127Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":19,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.553127Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:03eb683c4ed67ab1e407e42e75fd6df86b16a8befc5c554ce8f11da7ce5ede95","observation_id":"6a201951-e88c-4b49-a260-49f8fa22a8f7","resolution":{"observed_at":"2026-08-10T23:17:48.553127Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2304.11686","last_updated":"2023-09-09T09:55:18Z","snapshot_observed_at":"2026-08-16T15:38:22.925613Z","submitted_at":"2023-04-23T15:35:39Z","title":"Nuances are the Key: Unlocking ChatGPT to Find Failure-Inducing Tests with Differential Prompting","version":6},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2304.11686","snapshot_observed_at":"2026-08-10T23:17:48.558080Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":20,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.558080Z"},"links":{"cited_paper":"/paper/2304.11686","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:12faaf49eefd77d627f85fd9f31d641bf469885e575f90b2ffafb04b4fd55d5e","observation_id":"b72e6bac-6ac5-4e1a-9159-69cf45c2723e","resolution":{"observed_at":"2026-08-10T23:17:48.558080Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.024700Z","title":null,"venue":null,"work_id":"a046198a-17bc-4b32-ac55-367c75531342","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":21,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.563191Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:fd0fbe991485c0ed6298b4bfd4ccab5c1a4c428ebb85011544874550190db5eb","observation_id":"080036af-5a3d-4f08-ab63-e838e42803c3","resolution":{"observed_at":"2026-08-10T23:17:49.029273Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2308.07124","last_updated":"2024-02-18T09:46:06Z","snapshot_observed_at":"2026-08-16T15:08:39.154570Z","submitted_at":"2023-08-14T13:53:54Z","title":"OctoPack: Instruction Tuning Code Large Language Models","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.07124","snapshot_observed_at":"2026-08-10T23:17:48.568165Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":22,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.568165Z"},"links":{"cited_paper":"/paper/2308.07124","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:f52c85cb7b5e7db01a7b20d5fb63fa1c6013ebfbbcc320e0939be67279d6ec37","observation_id":"2be6b1e7-d69b-4b8d-8728-443a40ec9fbb","resolution":{"observed_at":"2026-08-10T23:17:48.568165Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2202.03286","last_updated":"2022-02-07T15:22:17Z","snapshot_observed_at":"2026-08-15T19:46:54.909325Z","submitted_at":"2022-02-07T15:22:17Z","title":"Red Teaming Language Models with Language Models","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2202.03286","snapshot_observed_at":"2026-08-10T23:17:48.572882Z","title":null,"venue":null,"work_id":null,"year":2022},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":23,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.572882Z"},"links":{"cited_paper":"/paper/2202.03286","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:9ee9e09f25e1ff2c044f175fa9c8cd3650e4d64b1e127f9d6351ae2ba50c76b9","observation_id":"cbe07dbe-945f-42e7-9c16-e16ecb2bab5e","resolution":{"observed_at":"2026-08-10T23:17:48.572882Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2307.16789","last_updated":"2023-10-03T14:45:48Z","snapshot_observed_at":"2026-08-16T04:18:30.717622Z","submitted_at":"2023-07-31T15:56:53Z","title":"ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2307.16789","snapshot_observed_at":"2026-08-10T23:17:48.577983Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":24,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.577983Z"},"links":{"cited_paper":"/paper/2307.16789","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:ab9acd918ba0211bd622aab733a3e9bf6ca286f8c059011e325c9ddfd60ad849","observation_id":"0c77ee0f-3af4-43d5-ab77-23ee59fb33f6","resolution":{"observed_at":"2026-08-10T23:17:48.577983Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2401.08500","last_updated":"2024-01-16T17:00:36Z","snapshot_observed_at":"2026-08-17T15:38:45.204670Z","submitted_at":"2024-01-16T17:00:36Z","title":"Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2401.08500","snapshot_observed_at":"2026-08-10T23:17:48.583121Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":25,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.583121Z"},"links":{"cited_paper":"/paper/2401.08500","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:7d595e5075f92a88d8af9255a4e9f053bbd9b597c70dc4509299e0a850073a2e","observation_id":"ca309695-8f37-4f14-9e4c-508e55086672","resolution":{"observed_at":"2026-08-10T23:17:48.583121Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2308.12950","last_updated":"2024-01-31T19:47:26Z","snapshot_observed_at":"2026-08-18T03:59:39.242039Z","submitted_at":"2023-08-24T17:39:13Z","title":"Code Llama: Open Foundation Models for Code","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.12950","snapshot_observed_at":"2026-08-10T23:17:48.587637Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":26,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.587637Z"},"links":{"cited_paper":"/paper/2308.12950","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:35d876078bd05c11b3eb78a79ff78baa117094e145e5d9b70a095212d063744a","observation_id":"97bb41a1-a13b-4ce3-a758-4789a6ff9684","resolution":{"observed_at":"2026-08-10T23:17:48.587637Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2408.03314","last_updated":"2024-08-06T17:35:05Z","snapshot_observed_at":"2026-07-06T02:11:23.670680Z","submitted_at":"2024-08-06T17:35:05Z","title":"Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2408.03314","snapshot_observed_at":"2026-08-10T23:17:48.591987Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":27,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.591987Z"},"links":{"cited_paper":"/paper/2408.03314","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:6b6aaeaf5b2fd549a649684f069008feb26f83e02f328fb5de2e0a361a139288","observation_id":"df65e31f-060e-4b0c-9c52-61308abcc822","resolution":{"observed_at":"2026-08-10T23:17:48.591987Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:49.011304Z","title":null,"venue":null,"work_id":"2fb3707b-6762-4840-940e-41add2d79753","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":28,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.596552Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:c0a4691c68bf46b8c83c9538197cafcc0b40649be731c6b986c2135383b28be1","observation_id":"b98eca70-76db-4cac-bd95-2e25c7267ec0","resolution":{"observed_at":"2026-08-10T23:17:49.015598Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.996311Z","title":null,"venue":null,"work_id":"b4c83968-e317-4a15-9b71-1607a4a63f27","year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":29,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.600619Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:2189e72f60f133d10d23a2c41c67d8294cca5180edf7fceb707e532ef7afaaa7","observation_id":"3487d7fb-32cb-44fc-aeb6-b602f736ed2a","resolution":{"observed_at":"2026-08-10T23:17:49.001625Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-20T06:33:59.587034+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2402.14658","last_updated":"2025-01-07T05:37:04Z","snapshot_observed_at":"2026-08-16T14:16:11.955412Z","submitted_at":"2024-02-22T16:06:23Z","title":"OpenCodeInterpreter: Integrating Code Generation with Execution and Refinement","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2402.14658","snapshot_observed_at":"2026-08-10T23:17:48.604751Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":30,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.604751Z"},"links":{"cited_paper":"/paper/2402.14658","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:694c2d1a513aceaeed497aec803e30264e37dd3f70add36787d82059f94f890d","observation_id":"24a9faf0-39d3-4aa7-91c6-79683d2ba8af","resolution":{"observed_at":"2026-08-10T23:17:48.604751Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2311.10372","last_updated":"2024-01-08T05:41:51Z","snapshot_observed_at":"2026-08-17T12:55:48.075480Z","submitted_at":"2023-11-17T07:55:16Z","title":"A Survey of Large Language Models for Code: Evolution, Benchmarking, and Future Trends","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2311.10372","snapshot_observed_at":"2026-08-10T23:17:48.608997Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":31,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.608997Z"},"links":{"cited_paper":"/paper/2311.10372","citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:aeb91d57df92d8dbf0cf3329657a21b6058712292120402bf57c327ae6180519","observation_id":"ffcc50a6-1da7-4085-ab9b-7176051bb317","resolution":{"observed_at":"2026-08-10T23:17:48.608997Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.613241Z","title":"online\" 'onlinestring :=","venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":32,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.613241Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:131f9d46b35cf6aa9526e2ecc114b2426e08adb6d41e34e725c004fd1848babd","observation_id":"99f1cda2-c20a-4fe5-bf4e-9cb9795f139f","resolution":{"observed_at":"2026-08-10T23:17:48.613241Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-10T23:17:48.617881Z","title":"write newline","venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement","version":2},"reference_index":33,"source":"arxiv_source","source_observed_at":"2026-08-10T23:17:48.617881Z"},"links":{"citing_paper":"/paper/2502.17442"},"observation_digest":"sha256:205d6a840b8a853a1c6a17b6baebacc663ef60872e65e5a4d6b1277aee33eb4c","observation_id":"eee1c6e5-d647-4565-b6ce-9bf9feaa30d3","resolution":{"observed_at":"2026-08-10T23:17:48.617881Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}}],"paper":{"arxiv_id":"2502.17442","last_updated":"2025-05-27T11:36:00Z","latest_version":2,"primary_category":"cs.SE","snapshot_observed_at":"2026-08-18T18:16:15.705835Z","submitted_at":"2024-12-30T07:02:15Z","title":"Thinking Before Running! Efficient Code Generation with Thorough Exploration and Optimal Refinement"},"reference_resolution":{"displayed":33,"state_counts":{"malformed_identifier":0,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":33,"verified_exact":0,"verified_fuzzy":0},"total_outbound_references":33},"refusal":"A citation records a reference. It does not transfer a finding from one paper to another.","schema":"pith.paper-citation-record.v1","standing_sources":[{"observed_at":"2026-08-20T06:33:59.587034+00:00","source":"crossref"},{"observed_at":"2026-08-20T06:33:54.927442+00:00","source":"retraction_watch"}],"thesis":"As of 20 August 2026, this Paper Citation Record lists 33 of 33 outbound references and 2 inbound Pith citation observations for arXiv:2502.17442."}